core: remove the unused files - round 2

BUG: 764890
Change-Id: I3eb626eeaa2a09f0e248444f560c2a0eaf46c642
Signed-off-by: Amar Tumballi <amarts@redhat.com>
Reviewed-on: http://review.gluster.com/3660
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Anand Avati <avati@redhat.com>

1 files changed, 0 insertions, 1019 deletions

diff --git a/scheduler/alu/src/alu.c b/scheduler/alu/src/alu.c
deleted file mode 100644
index 58bef60ae9f..00000000000
--- a/scheduler/alu/src/alu.c
+++ /dev/null
@@ -1,1019 +0,0 @@
-/*
-  Copyright (c) 2006-2011 Gluster, Inc. <http://www.gluster.com>
-  This file is part of GlusterFS.
-
-  GlusterFS 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 3 of the License,
-  or (at your option) any later version.
-
-  GlusterFS 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, see
-  <http://www.gnu.org/licenses/>.
-*/
-
-
-
-/* ALU code needs a complete re-write. This is one of the most important 
- * part of GlusterFS and so needs more and more reviews and testing 
- */
-
-#ifndef _CONFIG_H
-#define _CONFIG_H
-#include "config.h"
-#endif
-
-#include <sys/time.h>
-#include <stdint.h>
-#include "stack.h"
-#include "alu.h"
-#include "alu-mem-types.h"
-
-#define ALU_DISK_USAGE_ENTRY_THRESHOLD_DEFAULT         (1 * GF_UNIT_GB)
-#define ALU_DISK_USAGE_EXIT_THRESHOLD_DEFAULT          (512 * GF_UNIT_MB)
-
-#define ALU_WRITE_USAGE_ENTRY_THRESHOLD_DEFAULT        25
-#define ALU_WRITE_USAGE_EXIT_THRESHOLD_DEFAULT         5
-
-#define ALU_READ_USAGE_ENTRY_THRESHOLD_DEFAULT         25
-#define ALU_READ_USAGE_EXIT_THRESHOLD_DEFAULT          5
-
-#define ALU_OPEN_FILES_USAGE_ENTRY_THRESHOLD_DEFAULT   1000
-#define ALU_OPEN_FILES_USAGE_EXIT_THRESHOLD_DEFAULT    100
-
-#define ALU_LIMITS_TOTAL_DISK_SIZE_DEFAULT             100
-
-#define ALU_REFRESH_INTERVAL_DEFAULT                   5
-#define ALU_REFRESH_CREATE_COUNT_DEFAULT               5
-
-
-static int64_t 
-get_stats_disk_usage (struct xlator_stats *this)
-{
-	return this->disk_usage;
-}
-
-static int64_t 
-get_stats_write_usage (struct xlator_stats *this)
-{
-	return this->write_usage;
-}
-
-static int64_t 
-get_stats_read_usage (struct xlator_stats *this)
-{
-	return this->read_usage;
-}
-
-static int64_t 
-get_stats_disk_speed (struct xlator_stats *this)
-{
-	return this->disk_speed;
-}
-
-static int64_t 
-get_stats_file_usage (struct xlator_stats *this)
-{
-	/* Avoid warning "defined but not used" */
-	(void) &get_stats_file_usage;    
-
-	return this->nr_files;
-}
-
-static int64_t 
-get_stats_free_disk (struct xlator_stats *this)
-{
-	if (this->total_disk_size > 0)
-		return (this->free_disk * 100) / this->total_disk_size;
-	return 0;
-}
-
-static int64_t 
-get_max_diff_write_usage (struct xlator_stats *max, struct xlator_stats *min)
-{
-	return (max->write_usage - min->write_usage);
-}
-
-static int64_t 
-get_max_diff_read_usage (struct xlator_stats *max, struct xlator_stats *min)
-{
-	return (max->read_usage - min->read_usage);
-}
-
-static int64_t 
-get_max_diff_disk_usage (struct xlator_stats *max, struct xlator_stats *min)
-{
-	return (max->disk_usage - min->disk_usage);
-}
-
-static int64_t 
-get_max_diff_disk_speed (struct xlator_stats *max, struct xlator_stats *min)
-{
-	return (max->disk_speed - min->disk_speed);
-}
-
-static int64_t 
-get_max_diff_file_usage (struct xlator_stats *max, struct xlator_stats *min)
-{
-	return (max->nr_files - min->nr_files);
-}
-
-
-int 
-alu_parse_options (xlator_t *xl, struct alu_sched *alu_sched)
-{
-	data_t *order = dict_get (xl->options, "scheduler.alu.order");
-	if (!order) {
-		gf_log (xl->name, GF_LOG_ERROR,
-			"option 'scheduler.alu.order' not specified");
-		return -1;
-	}
-	struct alu_threshold *_threshold_fn;
-	struct alu_threshold *tmp_threshold;
-	data_t *entry_fn = NULL;
-	data_t *exit_fn = NULL;
-	char *tmp_str = NULL;
-	char *order_str = strtok_r (order->data, ":", &tmp_str);
-	/* Get the scheduling priority order, specified by the user. */
-	while (order_str) {
-		gf_log ("alu", GF_LOG_DEBUG,
-			"alu_init: order string: %s",
-			order_str);
-		if (strcmp (order_str, "disk-usage") == 0) {
-			/* Disk usage */
-			_threshold_fn = 
-				GF_CALLOC (1,
-                                           sizeof (struct alu_threshold),
-                                           gf_alu_mt_alu_threshold);
-			ERR_ABORT (_threshold_fn);
-			_threshold_fn->diff_value = get_max_diff_disk_usage;
-			_threshold_fn->sched_value = get_stats_disk_usage;
-			entry_fn = 
-				dict_get (xl->options, 
-					  "scheduler.alu.disk-usage.entry-threshold");
-			if (entry_fn) {
-				if (gf_string2bytesize (entry_fn->data, 
-							&alu_sched->entry_limit.disk_usage) != 0) {
-					gf_log (xl->name, GF_LOG_ERROR, 
-						"invalid number format \"%s\" "
-						"of \"option scheduler.alu."
-						"disk-usage.entry-threshold\"",
-						entry_fn->data);
-					return -1;
-				}
-			} else {
-				alu_sched->entry_limit.disk_usage = ALU_DISK_USAGE_ENTRY_THRESHOLD_DEFAULT;
-			}
-			_threshold_fn->entry_value = get_stats_disk_usage;
-			exit_fn = dict_get (xl->options, 
-					    "scheduler.alu.disk-usage.exit-threshold");
-			if (exit_fn) {
-				if (gf_string2bytesize (exit_fn->data, &alu_sched->exit_limit.disk_usage) != 0)	{
-					gf_log (xl->name, GF_LOG_ERROR, 
-						"invalid number format \"%s\" "
-						"of \"option scheduler.alu."
-						"disk-usage.exit-threshold\"", 
-						exit_fn->data);
-					return -1;
-				}
-			} else {
-				alu_sched->exit_limit.disk_usage = ALU_DISK_USAGE_EXIT_THRESHOLD_DEFAULT;
-			}
-			_threshold_fn->exit_value = get_stats_disk_usage;
-			tmp_threshold = alu_sched->threshold_fn;
-			if (!tmp_threshold) {
-				alu_sched->threshold_fn = _threshold_fn;
-			} else {
-				while (tmp_threshold->next) {
-					tmp_threshold = tmp_threshold->next;
-				}
-				tmp_threshold->next = _threshold_fn;
-			}
-			gf_log ("alu",
-				GF_LOG_DEBUG, "alu_init: = %"PRId64",%"PRId64"", 
-				alu_sched->entry_limit.disk_usage, 
-				alu_sched->exit_limit.disk_usage);
-			
-		} else if (strcmp (order_str, "write-usage") == 0) {
-			/* Handle "write-usage" */
-			
-			_threshold_fn = GF_CALLOC (1, sizeof (struct alu_threshold), gf_alu_mt_alu_threshold);
-			ERR_ABORT (_threshold_fn);
-			_threshold_fn->diff_value = get_max_diff_write_usage;
-			_threshold_fn->sched_value = get_stats_write_usage;
-			entry_fn = dict_get (xl->options, 
-					     "scheduler.alu.write-usage.entry-threshold");
-			if (entry_fn) {
-				if (gf_string2bytesize (entry_fn->data, 
-							&alu_sched->entry_limit.write_usage) != 0) {
-					gf_log (xl->name, GF_LOG_ERROR, 
-						"invalid number format \"%s\" "
-						"of option scheduler.alu."
-						"write-usage.entry-threshold", 
-						entry_fn->data);
-					return -1;
-				}
-			} else {
-				alu_sched->entry_limit.write_usage = ALU_WRITE_USAGE_ENTRY_THRESHOLD_DEFAULT;
-			}
-			_threshold_fn->entry_value = get_stats_write_usage;
-			exit_fn = dict_get (xl->options, 
-					    "scheduler.alu.write-usage.exit-threshold");
-			if (exit_fn) {
-				if (gf_string2bytesize (exit_fn->data, 
-							&alu_sched->exit_limit.write_usage) != 0) {
-					gf_log (xl->name, GF_LOG_ERROR, 
-						"invalid number format \"%s\""
-						" of \"option scheduler.alu."
-						"write-usage.exit-threshold\"",
-						exit_fn->data);
-					return -1;
-				}
-			} else {
-				alu_sched->exit_limit.write_usage = ALU_WRITE_USAGE_EXIT_THRESHOLD_DEFAULT;
-			}
-			_threshold_fn->exit_value = get_stats_write_usage;
-			tmp_threshold = alu_sched->threshold_fn;
-			if (!tmp_threshold) {
-				alu_sched->threshold_fn = _threshold_fn;
-			} else {
-				while (tmp_threshold->next) {
-					tmp_threshold = tmp_threshold->next;
-				}
-				tmp_threshold->next = _threshold_fn;
-			}
-			gf_log (xl->name, GF_LOG_DEBUG, 
-				"alu_init: = %"PRId64",%"PRId64"", 
-				alu_sched->entry_limit.write_usage, 
-				alu_sched->exit_limit.write_usage);
-			
-		} else if (strcmp (order_str, "read-usage") == 0) {
-			/* Read usage */
-			
-			_threshold_fn = GF_CALLOC (1, sizeof (struct alu_threshold), gf_alu_mt_alu_threshold);
-			ERR_ABORT (_threshold_fn);
-			_threshold_fn->diff_value = get_max_diff_read_usage;
-			_threshold_fn->sched_value = get_stats_read_usage;
-			entry_fn = dict_get (xl->options, 
-					     "scheduler.alu.read-usage.entry-threshold");
-			if (entry_fn) {
-				if (gf_string2bytesize (entry_fn->data, 
-							&alu_sched->entry_limit.read_usage) != 0) {
-					gf_log (xl->name, 
-						GF_LOG_ERROR, 
-						"invalid number format \"%s\" "
-						"of \"option scheduler.alu."
-						"read-usage.entry-threshold\"",
-						entry_fn->data);
-					return -1;
-				}
-			} else {
-				alu_sched->entry_limit.read_usage = ALU_READ_USAGE_ENTRY_THRESHOLD_DEFAULT;
-			}
-			_threshold_fn->entry_value = get_stats_read_usage;
-			exit_fn = dict_get (xl->options, 
-					    "scheduler.alu.read-usage.exit-threshold");
-			if (exit_fn)
-			{
-				if (gf_string2bytesize (exit_fn->data, 
-							&alu_sched->exit_limit.read_usage) != 0)
-				{
-					gf_log ("alu", GF_LOG_ERROR, 
-						"invalid number format \"%s\" "
-						"of \"option scheduler.alu."
-						"read-usage.exit-threshold\"", 
-						exit_fn->data);
-					return -1;
-				}
-			}
-			else
-			{
-				alu_sched->exit_limit.read_usage = ALU_READ_USAGE_EXIT_THRESHOLD_DEFAULT;
-			}
-			_threshold_fn->exit_value = get_stats_read_usage;
-			tmp_threshold = alu_sched->threshold_fn;
-			if (!tmp_threshold) {
-				alu_sched->threshold_fn = _threshold_fn;
-			}
-			else {
-				while (tmp_threshold->next) {
-					tmp_threshold = tmp_threshold->next;
-				}
-				tmp_threshold->next = _threshold_fn;
-			}
-			gf_log ("alu", GF_LOG_DEBUG, 
-				"alu_init: = %"PRId64",%"PRId64"", 
-				alu_sched->entry_limit.read_usage, 
-				alu_sched->exit_limit.read_usage);
-			
-		} else if (strcmp (order_str, "open-files-usage") == 0) {
-			/* Open files counter */
-			
-			_threshold_fn = GF_CALLOC (1, sizeof (struct alu_threshold), gf_alu_mt_alu_threshold);
-			ERR_ABORT (_threshold_fn);
-			_threshold_fn->diff_value = get_max_diff_file_usage;
-			_threshold_fn->sched_value = get_stats_file_usage;
-			entry_fn = dict_get (xl->options, 
-					     "scheduler.alu.open-files-usage.entry-threshold");
-			if (entry_fn) {
-				if (gf_string2uint64 (entry_fn->data, 
-						      &alu_sched->entry_limit.nr_files) != 0)
-				{
-					gf_log ("alu", GF_LOG_ERROR, 
-						"invalid number format \"%s\" "
-						"of \"option scheduler.alu."
-						"open-files-usage.entry-"
-						"threshold\"", entry_fn->data);
-					return -1;
-				}
-			}
-			else
-			{
-				alu_sched->entry_limit.nr_files = ALU_OPEN_FILES_USAGE_ENTRY_THRESHOLD_DEFAULT;
-			}
-			_threshold_fn->entry_value = get_stats_file_usage;
-			exit_fn = dict_get (xl->options, 
-					    "scheduler.alu.open-files-usage.exit-threshold");
-			if (exit_fn)
-			{
-				if (gf_string2uint64 (exit_fn->data, 
-						      &alu_sched->exit_limit.nr_files) != 0)
-				{
-					gf_log ("alu", GF_LOG_ERROR, 
-						"invalid number format \"%s\" "
-						"of \"option scheduler.alu."
-						"open-files-usage.exit-"
-						"threshold\"", exit_fn->data);
-					return -1;
-				}
-			}
-			else
-			{
-				alu_sched->exit_limit.nr_files = ALU_OPEN_FILES_USAGE_EXIT_THRESHOLD_DEFAULT;
-			}
-			_threshold_fn->exit_value = get_stats_file_usage;
-			tmp_threshold = alu_sched->threshold_fn;
-			if (!tmp_threshold) {
-				alu_sched->threshold_fn = _threshold_fn;
-			}
-			else {
-				while (tmp_threshold->next) {
-					tmp_threshold = tmp_threshold->next;
-				}
-				tmp_threshold->next = _threshold_fn;
-			}
-			gf_log ("alu", GF_LOG_DEBUG, 
-				"alu.c->alu_init: = %"PRIu64",%"PRIu64"", 
-				alu_sched->entry_limit.nr_files, 
-				alu_sched->exit_limit.nr_files);
-			
-		} else if (strcmp (order_str, "disk-speed-usage") == 0) {
-			/* Disk speed */
-			
-			_threshold_fn = GF_CALLOC (1, sizeof (struct alu_threshold), gf_alu_mt_alu_threshold);
-			ERR_ABORT (_threshold_fn);
-			_threshold_fn->diff_value = get_max_diff_disk_speed;
-			_threshold_fn->sched_value = get_stats_disk_speed;
-			entry_fn = dict_get (xl->options, 
-					     "scheduler.alu.disk-speed-usage.entry-threshold");
-			if (entry_fn) {
-				gf_log ("alu", GF_LOG_DEBUG,
-					"entry-threshold is given, "
-					"value is constant");
-			}
-			_threshold_fn->entry_value = NULL;
-			exit_fn = dict_get (xl->options, 
-					    "scheduler.alu.disk-speed-usage.exit-threshold");
-			if (exit_fn) {
-				gf_log ("alu", GF_LOG_DEBUG,
-					"exit-threshold is given, "
-					"value is constant");
-			}
-			_threshold_fn->exit_value = NULL;
-			tmp_threshold = alu_sched->threshold_fn;
-			if (!tmp_threshold) {
-				alu_sched->threshold_fn = _threshold_fn;
-			}
-			else {
-				while (tmp_threshold->next) {
-					tmp_threshold = tmp_threshold->next;
-				}
-				tmp_threshold->next = _threshold_fn;
-			}
-			
-		} else {
-			gf_log ("alu", GF_LOG_DEBUG,
-				"%s, unknown option provided to scheduler",
-				order_str);
-		}
-		order_str = strtok_r (NULL, ":", &tmp_str);
-	}
-	
-	return 0;
-}
-
-static int32_t
-alu_init (xlator_t *xl)
-{
-	struct alu_sched *alu_sched = NULL;
-	struct alu_limits *_limit_fn = NULL;
-	struct alu_limits *tmp_limits = NULL;
-	uint32_t min_free_disk = 0;
-	data_t *limits = NULL;
-  
-	alu_sched = GF_CALLOC (1, sizeof (struct alu_sched),
-                               gf_alu_mt_alu_sched);
-	ERR_ABORT (alu_sched);
-
-	{
-		alu_parse_options (xl, alu_sched);
-	}
-
-	/* Get the limits */
-	
-	limits = dict_get (xl->options, 
-			   "scheduler.limits.min-free-disk");
-	if (limits) {
-		_limit_fn = GF_CALLOC (1, sizeof (struct alu_limits),
-                                       gf_alu_mt_alu_limits);
-		ERR_ABORT (_limit_fn);
-		_limit_fn->min_value = get_stats_free_disk;
-		_limit_fn->cur_value = get_stats_free_disk;
-		tmp_limits = alu_sched->limits_fn ;
-		_limit_fn->next = tmp_limits;
-		alu_sched->limits_fn = _limit_fn;
-		
-		if (gf_string2percent (limits->data, 
-				       &min_free_disk) != 0) {
-			gf_log ("alu", GF_LOG_ERROR, 
-				"invalid number format \"%s\" "
-				"of \"option scheduler.limits."
-				"min-free-disk\"", limits->data);
-			return -1;
-		}
-		alu_sched->spec_limit.free_disk = min_free_disk;
-		
-		if (alu_sched->spec_limit.free_disk >= 100) {
-			gf_log ("alu", GF_LOG_ERROR,
-				"check the \"option scheduler."
-				"limits.min-free-disk\", it should "
-				"be percentage value");
-			return -1;
-		}
-		alu_sched->spec_limit.total_disk_size = ALU_LIMITS_TOTAL_DISK_SIZE_DEFAULT; /* Its in % */
-		gf_log ("alu", GF_LOG_DEBUG,
-			"alu.limit.min-disk-free = %"PRId64"", 
-			_limit_fn->cur_value (&(alu_sched->spec_limit)));
-	}
-	
-	limits = dict_get (xl->options, 
-			   "scheduler.limits.max-open-files");
-	if (limits) {
-		// Update alu_sched->priority properly
-		_limit_fn = GF_CALLOC (1, sizeof (struct alu_limits),
-                                       gf_alu_mt_alu_limits);
-		ERR_ABORT (_limit_fn);
-		_limit_fn->max_value = get_stats_file_usage;
-		_limit_fn->cur_value = get_stats_file_usage;
-		tmp_limits = alu_sched->limits_fn ;
-		_limit_fn->next = tmp_limits;
-		alu_sched->limits_fn = _limit_fn;
-		if (gf_string2uint64_base10 (limits->data, 
-					     &alu_sched->spec_limit.nr_files) != 0)
-		{
-			gf_log ("alu", GF_LOG_ERROR, 
-				"invalid number format '%s' of option "
-				"scheduler.limits.max-open-files", 
-				limits->data);
-			return -1;
-		}
-		
-		gf_log ("alu", GF_LOG_DEBUG,
-			"alu_init: limit.max-open-files = %"PRId64"",
-			_limit_fn->cur_value (&(alu_sched->spec_limit)));
-	}
-
-
-	/* Stats refresh options */
-	limits = dict_get (xl->options, 
-			   "scheduler.refresh-interval");
-	if (limits) {
-		if (gf_string2time (limits->data, 
-				    &alu_sched->refresh_interval) != 0)	{
-			gf_log ("alu", GF_LOG_ERROR, 
-				"invalid number format \"%s\" of "
-				"option scheduler.refresh-interval", 
-				limits->data);
-			return -1;
-		}
-	} else {
-		alu_sched->refresh_interval = ALU_REFRESH_INTERVAL_DEFAULT;
-	}
-	gettimeofday (&(alu_sched->last_stat_fetch), NULL);
-	
-	
-	limits = dict_get (xl->options, 
-			   "scheduler.alu.stat-refresh.num-file-create");
-	if (limits) {
-		if (gf_string2uint32 (limits->data, 
-				      &alu_sched->refresh_create_count) != 0)
-		{
-			gf_log ("alu", GF_LOG_ERROR, 
-				"invalid number format \"%s\" of \"option "
-				"alu.stat-refresh.num-file-create\"", 
-				limits->data);
-			return -1;
-		}
-	} else {
-		alu_sched->refresh_create_count = ALU_REFRESH_CREATE_COUNT_DEFAULT;
-	}
-
-	{
-		/* Build an array of child_nodes */
-		struct alu_sched_struct *sched_array = NULL;
-		xlator_list_t *trav_xl = xl->children;
-		data_t *data = NULL;
-		int32_t index = 0;
-		
-		while (trav_xl) {
-			index++;
-			trav_xl = trav_xl->next;
-		}
-		alu_sched->child_count = index;
-		sched_array = GF_CALLOC (index, sizeof (struct alu_sched_struct), gf_alu_mt_alu_sched_struct);
-		ERR_ABORT (sched_array);
-		trav_xl = xl->children;
-		index = 0;
-		while (trav_xl) {
-			sched_array[index].xl = trav_xl->xlator;
-			sched_array[index].eligible = 1;
-			index++;
-			trav_xl = trav_xl->next;
-		}
-		alu_sched->array = sched_array;
-
-		data = dict_get (xl->options, 
-				 "scheduler.read-only-subvolumes");
-		if (data) {
-			char *child = NULL;
-			char *tmp = NULL;
-			char *childs_data = gf_strdup (data->data);
-      
-			child = strtok_r (childs_data, ",", &tmp);
-			while (child) {
-				for (index = 1; index < alu_sched->child_count; index++) {
-					if (strcmp (alu_sched->array[index -1].xl->name, child) == 0) {
-						memcpy (&(alu_sched->array[index -1]), 
-							&(alu_sched->array[alu_sched->child_count -1]), 
-							sizeof (struct alu_sched_struct));
-						alu_sched->child_count--;
-						break;
-					}
-				}
-				child = strtok_r (NULL, ",", &tmp);
-			}
-		}
-	}
-
-	*((long *)xl->private) = (long)alu_sched;
-
-	/* Initialize all the alu_sched structure's elements */
-	{
-		alu_sched->sched_nodes_pending = 0;
-
-		alu_sched->min_limit.free_disk = 0x00FFFFFF;
-		alu_sched->min_limit.disk_usage = 0xFFFFFFFF;
-		alu_sched->min_limit.total_disk_size = 0xFFFFFFFF;
-		alu_sched->min_limit.disk_speed = 0xFFFFFFFF;
-		alu_sched->min_limit.write_usage = 0xFFFFFFFF;
-		alu_sched->min_limit.read_usage = 0xFFFFFFFF;
-		alu_sched->min_limit.nr_files = 0xFFFFFFFF;
-		alu_sched->min_limit.nr_clients = 0xFFFFFFFF;
-	}
-
-	pthread_mutex_init (&alu_sched->alu_mutex, NULL);
-	return 0;
-}
-
-static void
-alu_fini (xlator_t *xl)
-{
-	if (!xl)
-		return;
-	struct alu_sched *alu_sched = (struct alu_sched *)*((long *)xl->private);
-	struct alu_limits *limit = alu_sched->limits_fn;
-	struct alu_threshold *threshold = alu_sched->threshold_fn;
-	void *tmp = NULL;
-	pthread_mutex_destroy (&alu_sched->alu_mutex);
-	GF_FREE (alu_sched->array);
-	while (limit) {
-		tmp = limit;
-		limit = limit->next;
-		GF_FREE (tmp);
-	}
-	while (threshold) {
-		tmp = threshold;
-		threshold = threshold->next;
-		GF_FREE (tmp);
-	}
-	GF_FREE (alu_sched);
-}
-
-static int32_t 
-update_stat_array_cbk (call_frame_t *frame,
-		       void *cookie,
-		       xlator_t *xl,
-		       int32_t op_ret,
-		       int32_t op_errno,
-		       struct xlator_stats *trav_stats)
-{
-	struct alu_sched *alu_sched = (struct alu_sched *)*((long *)xl->private);
-	struct alu_limits *limits_fn = alu_sched->limits_fn;
-	int32_t idx = 0;
-  
-	pthread_mutex_lock (&alu_sched->alu_mutex);
-	for (idx = 0; idx < alu_sched->child_count; idx++) {
-		if (alu_sched->array[idx].xl == (xlator_t *)cookie)
-			break;
-	}
-	pthread_mutex_unlock (&alu_sched->alu_mutex);
-
-	if (op_ret == -1) {
-		alu_sched->array[idx].eligible = 0;
-	} else {
-		memcpy (&(alu_sched->array[idx].stats), trav_stats, sizeof (struct xlator_stats));
-    
-		/* Get stats from all the child node */
-		/* Here check the limits specified by the user to 
-		   consider the nodes to be used by scheduler */
-		alu_sched->array[idx].eligible = 1;
-		limits_fn = alu_sched->limits_fn;
-		while (limits_fn){
-			if (limits_fn->max_value && 
-			    (limits_fn->cur_value (trav_stats) > 
-			     limits_fn->max_value (&(alu_sched->spec_limit)))) {
-				alu_sched->array[idx].eligible = 0;
-			}
-			if (limits_fn->min_value && 
-			    (limits_fn->cur_value (trav_stats) < 
-			     limits_fn->min_value (&(alu_sched->spec_limit)))) {
-				alu_sched->array[idx].eligible = 0;
-			}
-			limits_fn = limits_fn->next;
-		}
-
-		/* Select minimum and maximum disk_usage */
-		if (trav_stats->disk_usage > alu_sched->max_limit.disk_usage) {
-			alu_sched->max_limit.disk_usage = trav_stats->disk_usage;
-		}
-		if (trav_stats->disk_usage < alu_sched->min_limit.disk_usage) {
-			alu_sched->min_limit.disk_usage = trav_stats->disk_usage;
-		}
-
-		/* Select minimum and maximum disk_speed */
-		if (trav_stats->disk_speed > alu_sched->max_limit.disk_speed) {
-			alu_sched->max_limit.disk_speed = trav_stats->disk_speed;
-		}
-		if (trav_stats->disk_speed < alu_sched->min_limit.disk_speed) {
-			alu_sched->min_limit.disk_speed = trav_stats->disk_speed;
-		}
-
-		/* Select minimum and maximum number of open files */
-		if (trav_stats->nr_files > alu_sched->max_limit.nr_files) {
-			alu_sched->max_limit.nr_files = trav_stats->nr_files;
-		}
-		if (trav_stats->nr_files < alu_sched->min_limit.nr_files) {
-			alu_sched->min_limit.nr_files = trav_stats->nr_files;
-		}
-
-		/* Select minimum and maximum write-usage */
-		if (trav_stats->write_usage > alu_sched->max_limit.write_usage) {
-			alu_sched->max_limit.write_usage = trav_stats->write_usage;
-		}
-		if (trav_stats->write_usage < alu_sched->min_limit.write_usage) {
-			alu_sched->min_limit.write_usage = trav_stats->write_usage;
-		}
-
-		/* Select minimum and maximum read-usage */
-		if (trav_stats->read_usage > alu_sched->max_limit.read_usage) {
-			alu_sched->max_limit.read_usage = trav_stats->read_usage;
-		}
-		if (trav_stats->read_usage < alu_sched->min_limit.read_usage) {
-			alu_sched->min_limit.read_usage = trav_stats->read_usage;
-		}
-
-		/* Select minimum and maximum free-disk */
-		if (trav_stats->free_disk > alu_sched->max_limit.free_disk) {
-			alu_sched->max_limit.free_disk = trav_stats->free_disk;
-		}
-		if (trav_stats->free_disk < alu_sched->min_limit.free_disk) {
-			alu_sched->min_limit.free_disk = trav_stats->free_disk;
-		}
-	}
-
-	STACK_DESTROY (frame->root);
-
-	return 0;
-}
-
-static void 
-update_stat_array (xlator_t *xl)
-{
-	/* This function schedules the file in one of the child nodes */
-	struct alu_sched *alu_sched = (struct alu_sched *)*((long *)xl->private);
-	int32_t idx = 0;
-	call_frame_t *frame = NULL;
-	call_pool_t *pool = xl->ctx->pool;
-
-	for (idx = 0 ; idx < alu_sched->child_count; idx++) {
-		frame = create_frame (xl, pool);
-
-		STACK_WIND_COOKIE (frame,
-				   update_stat_array_cbk, 
-				   alu_sched->array[idx].xl, //cookie
-				   alu_sched->array[idx].xl, 
-				   (alu_sched->array[idx].xl)->mops->stats,
-				   0); //flag
-	}
-	return;
-}
-
-static void 
-alu_update (xlator_t *xl)
-{
-	struct timeval tv;
-	struct alu_sched *alu_sched = (struct alu_sched *)*((long *)xl->private);
-
-	gettimeofday (&tv, NULL);
-	if (tv.tv_sec > (alu_sched->refresh_interval + alu_sched->last_stat_fetch.tv_sec)) {
-		/* Update the stats from all the server */
-		update_stat_array (xl);
-		alu_sched->last_stat_fetch.tv_sec = tv.tv_sec;
-	}
-}
-
-static xlator_t *
-alu_scheduler (xlator_t *xl, const void *path)
-{
-	/* This function schedules the file in one of the child nodes */
-	struct alu_sched *alu_sched = (struct alu_sched *)*((long *)xl->private);
-	int32_t sched_index = 0;
-	int32_t sched_index_orig = 0;
-	int32_t idx = 0;
-
-	alu_update (xl);
-
-	/* Now check each threshold one by one if some nodes are classified */
-	{
-		struct alu_threshold *trav_threshold = alu_sched->threshold_fn;
-		struct alu_threshold *tmp_threshold = alu_sched->sched_method;
-		struct alu_sched_node *tmp_sched_node;   
-
-		/* This pointer 'trav_threshold' contains function pointers according to spec file
-		   give by user, */
-		while (trav_threshold) {
-			/* This check is needed for seeing if already there are nodes in this criteria 
-			   to be scheduled */
-			if (!alu_sched->sched_nodes_pending) {
-				for (idx = 0; idx < alu_sched->child_count; idx++) {
-					if (!alu_sched->array[idx].eligible) {
-						continue;
-					}
-					if (trav_threshold->entry_value) {
-						if (trav_threshold->diff_value (&(alu_sched->max_limit),
-										&(alu_sched->array[idx].stats)) <
-						    trav_threshold->entry_value (&(alu_sched->entry_limit))) {
-							continue;
-						}
-					}
-					tmp_sched_node = GF_CALLOC (1, sizeof (struct alu_sched_node), gf_alu_mt_alu_sched_node);
-					ERR_ABORT (tmp_sched_node);
-					tmp_sched_node->index = idx;
-					if (!alu_sched->sched_node) {
-						alu_sched->sched_node = tmp_sched_node;
-					} else {
-						pthread_mutex_lock (&alu_sched->alu_mutex);
-						tmp_sched_node->next = alu_sched->sched_node;
-						alu_sched->sched_node = tmp_sched_node;
-						pthread_mutex_unlock (&alu_sched->alu_mutex);
-					}
-					alu_sched->sched_nodes_pending++;
-				}
-			} /* end of if (sched_nodes_pending) */
-
-			/* This loop is required to check the eligible nodes */
-			struct alu_sched_node *trav_sched_node;
-			while (alu_sched->sched_nodes_pending) {
-				trav_sched_node = alu_sched->sched_node;
-				sched_index = trav_sched_node->index;
-				if (alu_sched->array[sched_index].eligible)
-					break;
-				alu_sched->sched_node = trav_sched_node->next;
-				GF_FREE (trav_sched_node);
-				alu_sched->sched_nodes_pending--;
-			}
-			if (alu_sched->sched_nodes_pending) {
-				/* There are some node in this criteria to be scheduled, no need 
-				 * to sort and check other methods 
-				 */
-				if (tmp_threshold && tmp_threshold->exit_value) {
-					/* verify the exit value && whether node is eligible or not */
-					if (tmp_threshold->diff_value (&(alu_sched->max_limit),
-								       &(alu_sched->array[sched_index].stats)) >
-					    tmp_threshold->exit_value (&(alu_sched->exit_limit))) {
-						/* Free the allocated info for the node :) */
-						pthread_mutex_lock (&alu_sched->alu_mutex);
-						alu_sched->sched_node = trav_sched_node->next;
-						GF_FREE (trav_sched_node);
-						trav_sched_node = alu_sched->sched_node;
-						alu_sched->sched_nodes_pending--;
-						pthread_mutex_unlock (&alu_sched->alu_mutex);
-					}
-				} else {
-					/* if there is no exit value, then exit after scheduling once */
-					pthread_mutex_lock (&alu_sched->alu_mutex);
-					alu_sched->sched_node = trav_sched_node->next;
-					GF_FREE (trav_sched_node);
-					trav_sched_node = alu_sched->sched_node;
-					alu_sched->sched_nodes_pending--;
-					pthread_mutex_unlock (&alu_sched->alu_mutex);
-				}
-	
-				alu_sched->sched_method = tmp_threshold; /* this is the method used for selecting */
-
-				/* */
-				if (trav_sched_node) {
-					tmp_sched_node = trav_sched_node;
-					while (trav_sched_node->next) {
-						trav_sched_node = trav_sched_node->next;
-					}
-					if (tmp_sched_node->next) {
-						pthread_mutex_lock (&alu_sched->alu_mutex);
-						alu_sched->sched_node = tmp_sched_node->next;
-						tmp_sched_node->next = NULL;
-						trav_sched_node->next = tmp_sched_node;
-						pthread_mutex_unlock (&alu_sched->alu_mutex);
-					}
-				}
-				/* return the scheduled node */
-				return alu_sched->array[sched_index].xl;
-			} /* end of if (pending_nodes) */
-      
-			tmp_threshold = trav_threshold;
-			trav_threshold = trav_threshold->next;
-		}
-	}
-  
-	/* This is used only when there is everything seems ok, or no eligible nodes */
-	sched_index_orig = alu_sched->sched_index;
-	alu_sched->sched_method = NULL;
-	while (1) {
-		//lock
-		pthread_mutex_lock (&alu_sched->alu_mutex);
-		sched_index = alu_sched->sched_index++;
-		alu_sched->sched_index = alu_sched->sched_index % alu_sched->child_count;
-		pthread_mutex_unlock (&alu_sched->alu_mutex);
-		//unlock
-		if (alu_sched->array[sched_index].eligible)
-			break;
-		if (sched_index_orig == (sched_index + 1) % alu_sched->child_count) {
-			gf_log ("alu", GF_LOG_WARNING, "No node is eligible to schedule");
-			//lock
-			pthread_mutex_lock (&alu_sched->alu_mutex);
-			alu_sched->sched_index++;
-			alu_sched->sched_index = alu_sched->sched_index % alu_sched->child_count;
-			pthread_mutex_unlock (&alu_sched->alu_mutex);
-			//unlock
-			break;
-		}
-	}
-	return alu_sched->array[sched_index].xl;
-}
-
-/**
- * notify
- */
-void
-alu_notify (xlator_t *xl, int32_t event, void *data)
-{
-	struct alu_sched *alu_sched = NULL; 
-	int32_t idx = 0;
-  
-	alu_sched = (struct alu_sched *)*((long *)xl->private);
-	if (!alu_sched)
-		return;
-
-	for (idx = 0; idx < alu_sched->child_count; idx++) {
-		if (alu_sched->array[idx].xl == (xlator_t *)data)
-			break;
-	}
-
-	switch (event)
-	{
-	case GF_EVENT_CHILD_UP:
-	{
-		//alu_sched->array[idx].eligible = 1;
-	}
-	break;
-	case GF_EVENT_CHILD_DOWN:
-	{
-		alu_sched->array[idx].eligible = 0;
-	}
-	break;
-	default:
-	{
-		;
-	}
-	break;
-	}
-
-}
-
-int32_t
-alu_mem_acct_init (xlator_t *this)
-{
-        int     ret = -1;
-
-        if (!this)
-                return ret;
-
-        ret = xlator_mem_acct_init (this, gf_alu_mt_end + 1);
-        
-        if (ret != 0) {
-                gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
-                                "failed");
-                return ret;
-        }
-
-        return ret;
-}
-
-struct sched_ops sched = {
-	.init     = alu_init,
-	.fini     = alu_fini,
-	.update   = alu_update,
-	.schedule = alu_scheduler,
-	.notify   = alu_notify,
-        .mem_acct_init = alu_mem_acct_init,
-};
-
-struct volume_options options[] = {
-	{ .key   = { "scheduler.alu.order", "alu.order" },  
-	  .type  = GF_OPTION_TYPE_ANY 
-	},
-	{ .key   = { "scheduler.alu.disk-usage.entry-threshold", 
-		     "alu.disk-usage.entry-threshold" },  
-	  .type  = GF_OPTION_TYPE_SIZET
-	},
-	{ .key   = { "scheduler.alu.disk-usage.exit-threshold", 
-		     "alu.disk-usage.exit-threshold" },  
-	  .type  = GF_OPTION_TYPE_SIZET
-	},
-	{ .key   = { "scheduler.alu.write-usage.entry-threshold", 
-		     "alu.write-usage.entry-threshold" },  
-	  .type  = GF_OPTION_TYPE_SIZET
-	},
-	{ .key   = { "scheduler.alu.write-usage.exit-threshold", 
-		     "alu.write-usage.exit-threshold" },  
-	  .type  = GF_OPTION_TYPE_SIZET 
-	},
-	{ .key   = { "scheduler.alu.read-usage.entry-threshold", 
-		     "alu.read-usage.entry-threshold" },  
-	  .type  = GF_OPTION_TYPE_SIZET
-	},
-	{ .key   = { "scheduler.alu.read-usage.exit-threshold", 
-		     "alu.read-usage.exit-threshold" },  
-	  .type  = GF_OPTION_TYPE_SIZET 
-	},
-	{ .key   = { "scheduler.alu.open-files-usage.entry-threshold", 
-		     "alu.open-files-usage.entry-threshold" },  
-	  .type  = GF_OPTION_TYPE_INT
-	},
-	{ .key   = { "scheduler.alu.open-files-usage.exit-threshold", 
-		     "alu.open-files-usage.exit-threshold" },  
-	  .type  = GF_OPTION_TYPE_INT 
-	},
-	{ .key   = { "scheduler.read-only-subvolumes",
-		     "alu.read-only-subvolumes" },  
-	  .type  = GF_OPTION_TYPE_ANY 
-	},
-	{ .key   = { "scheduler.refresh-interval", 
-		     "alu.refresh-interval",
-		     "alu.stat-refresh.interval" },
-	  .type  = GF_OPTION_TYPE_TIME
-	},
-	{ .key   = { "scheduler.limits.min-free-disk", 
-		     "alu.limits.min-free-disk" },  
-	  .type  = GF_OPTION_TYPE_PERCENT
-	},
-	{ .key   = { "scheduler.alu.stat-refresh.num-file-create"
-		     "alu.stat-refresh.num-file-create"},  
-	  .type  = GF_OPTION_TYPE_INT
-	},
-	{ .key  =  {NULL}, }
-};