text:
#include <linux/version.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/pci.h>
#include <linux/kthread.h>
#include <linux/rwsem.h>
#include <linux/mutex.h>
#include <linux/nsproxy.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>

#include <exec-env/rte_kni_common.h>

#include "compat.h"
#include "kni_dev.h"

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Intel Corporation");
MODULE_DESCRIPTION("Kernel Module for managing kni devices");

#define KNI_RX_LOOP_NUM 1000

#define KNI_MAX_DEVICES 32

extern const struct pci_device_id ixgbe_pci_tbl[];
extern const struct pci_device_id igb_pci_tbl[];

/* loopback mode */
static char *lo_mode;

/* Kernel thread mode */
static char *kthread_mode;
static uint32_t multiple_kthread_on;

#define KNI_DEV_IN_USE_BIT_NUM 0 /* Bit number for device in use */

static int kni_net_id;

struct kni_net {
	unsigned long device_in_use; /* device in use flag */
	struct mutex kni_kthread_lock;
	struct task_struct *kni_kthread;
	struct rw_semaphore kni_list_lock;
	struct list_head kni_list_head;
};

static int __net_init
kni_init_net(struct net *net)
{
#ifdef HAVE_SIMPLIFIED_PERNET_OPERATIONS
	struct kni_net *knet = net_generic(net, kni_net_id);

	memset(knet, 0, sizeof(*knet));
#else
	struct kni_net *knet;
	int ret;

	knet = kzalloc(sizeof(struct kni_net), GFP_KERNEL);
	if (!knet) {
		ret = -ENOMEM;
		return ret;
	}
#endif

	/* Clear the bit of device in use */
	clear_bit(KNI_DEV_IN_USE_BIT_NUM, &knet->device_in_use);

	mutex_init(&knet->kni_kthread_lock);

	init_rwsem(&knet->kni_list_lock);
	INIT_LIST_HEAD(&knet->kni_list_head);

#ifdef HAVE_SIMPLIFIED_PERNET_OPERATIONS
	return 0;
#else
	ret = net_assign_generic(net, kni_net_id, knet);
	if (ret < 0)
		kfree(knet);

	return ret;
#endif
}

static void __net_exit
kni_exit_net(struct net *net)
{
	struct kni_net *knet __maybe_unused;

	knet = net_generic(net, kni_net_id);
	mutex_destroy(&knet->kni_kthread_lock);

#ifndef HAVE_SIMPLIFIED_PERNET_OPERATIONS
	kfree(knet);
#endif
}

static struct pernet_operations kni_net_ops = {
	.init = kni_init_net,
	.exit = kni_exit_net,
#ifdef HAVE_SIMPLIFIED_PERNET_OPERATIONS
	.id   = &kni_net_id,
	.size = sizeof(struct kni_net),
#endif
};

static int
kni_thread_single(void *data)
{
	struct kni_net *knet = data;
	int j;
	struct kni_dev *dev;

	while (!kthread_should_stop()) {
		down_read(&knet->kni_list_lock);
		for (j = 0; j < KNI_RX_LOOP_NUM; j++) {
			list_for_each_entry(dev, &knet->kni_list_head, list) {
				kni_net_rx(dev);
				kni_net_poll_resp(dev);
			}
		}
		up_read(&knet->kni_list_lock);
#ifdef RTE_KNI_PREEMPT_DEFAULT
		/* reschedule out for a while */
		schedule_timeout_interruptible(
			usecs_to_jiffies(KNI_KTHREAD_RESCHEDULE_INTERVAL));
#endif
	}

	return 0;
}

static int
kni_thread_multiple(void *param)
{
	int j;
	struct kni_dev *dev = param;

	while (!kthread_should_stop()) {
		for (j = 0; j < KNI_RX_LOOP_NUM; j++) {
			kni_net_rx(dev);
			kni_net_poll_resp(dev);
		}
#ifdef RTE_KNI_PREEMPT_DEFAULT
		schedule_timeout_interruptible(
			usecs_to_jiffies(KNI_KTHREAD_RESCHEDULE_INTERVAL));
#endif
	}

	return 0;
}

static int
kni_open(struct inode *inode, struct file *file)
{
	struct net *net = current->nsproxy->net_ns;
	struct kni_net *knet = net_generic(net, kni_net_id);

	/* kni device can be opened by one user only per netns */
	if (test_and_set_bit(KNI_DEV_IN_USE_BIT_NUM, &knet->device_in_use))
		return -EBUSY;

	file->private_data = get_net(net);
	pr_debug("/dev/kni opened\n");

	return 0;
}

static int
kni_dev_remove(struct kni_dev *dev)
{
	if (!dev)
		return -ENODEV;

#ifdef RTE_KNI_KMOD_ETHTOOL
	if (dev->pci_dev) {
		if (pci_match_id(ixgbe_pci_tbl, dev->pci_dev))
			ixgbe_kni_remove(dev->pci_dev);
		else if (pci_match_id(igb_pci_tbl, dev->pci_dev))
			igb_kni_remove(dev->pci_dev);
	}
#endif

	if (dev->net_dev) {
		unregister_netdev(dev->net_dev);
		free_netdev(dev->net_dev);
	}

	return 0;
}

static int
kni_release(struct inode *inode, struct file *file)
{
	struct net *net = file->private_data;
	struct kni_net *knet = net_generic(net, kni_net_id);
	struct kni_dev *dev, *n;

	/* Stop kernel thread for single mode */
	if (multiple_kthread_on == 0) {
		mutex_lock(&knet->kni_kthread_lock);
		/* Stop kernel thread */
		if (knet->kni_kthread != NULL) {
			kthread_stop(knet->kni_kthread);
			knet->kni_kthread = NULL;
		}
		mutex_unlock(&knet->kni_kthread_lock);
	}

	down_write(&knet->kni_list_lock);
	list_for_each_entry_safe(dev, n, &knet->kni_list_head, list) {
		/* Stop kernel thread for multiple mode */
		if (multiple_kthread_on && dev->pthread != NULL) {
			kthread_stop(dev->pthread);
			dev->pthread = NULL;
		}

		kni_dev_remove(dev);
		list_del(&dev->list);
	}
	up_write(&knet->kni_list_lock);

	/* Clear the bit of device in use */
	clear_bit(KNI_DEV_IN_USE_BIT_NUM, &knet->device_in_use);

	put_net(net);
	pr_debug("/dev/kni closed\n");

	return 0;
}

static int
kni_check_param(struct kni_dev *kni, struct rte_kni_device_info *dev)
{
	if (!kni || !dev)
		return -1;

	/* Check if network name has been used */
	if (!strncmp(kni->name, dev->name, RTE_KNI_NAMESIZE)) {
		pr_err("KNI name %s duplicated\n", dev->name);
		return -1;
	}

	return 0;
}

static int
kni_run_thread(struct kni_net *knet, struct kni_dev *kni, uint8_t force_bind)
{
	/**
	 * Create a new kernel thread for multiple mode, set its core affinity,
	 * and finally wake it up.
	 */
	if (multiple_kthread_on) {
		kni->pthread = kthread_create(kni_thread_multiple,
			(void *)kni, "kni_%s", kni->name);
		if (IS_ERR(kni->pthread)) {
			kni_dev_remove(kni);
			return -ECANCELED;
		}

		if (force_bind)
			kthread_bind(kni->pthread, kni->core_id);
		wake_up_process(kni->pthread);
	} else {
		mutex_lock(&knet->kni_kthread_lock);

		if (knet->kni_kthread == NULL) {
			knet->kni_kthread = kthread_create(kni_thread_single,
				(void *)knet, "kni_single");
			if (IS_ERR(knet->kni_kthread)) {
				mutex_unlock(&knet->kni_kthread_lock);
				kni_dev_remove(kni);
				return -ECANCELED;
			}

			if (force_bind)
				kthread_bind(knet->kni_kthread, kni->core_id);
			wake_up_process(knet->kni_kthread);
		}

		mutex_unlock(&knet->kni_kthread_lock);
	}

	return 0;
}

static int
kni_ioctl_create(struct net *net, uint32_t ioctl_num,
		unsigned long ioctl_param)
{
	struct kni_net *knet = net_generic(net, kni_net_id);
	int ret;
	struct rte_kni_device_info dev_info;
	struct net_device *net_dev = NULL;
	struct kni_dev *kni, *dev, *n;
#ifdef RTE_KNI_KMOD_ETHTOOL
	struct pci_dev *found_pci = NULL;
	struct net_device *lad_dev = NULL;
	struct pci_dev *pci = NULL;
#endif

	pr_info("Creating kni...\n");
	/* Check the buffer size, to avoid warning */
	if (_IOC_SIZE(ioctl_num) > sizeof(dev_info))
		return -EINVAL;

	/* Copy kni info from user space */
	ret = copy_from_user(&dev_info, (void *)ioctl_param, sizeof(dev_info));
	if (ret) {
		pr_err("copy_from_user in kni_ioctl_create");
		return -EIO;
	}

	/* Check if name is zero-ended */
	if (strnlen(dev_info.name, sizeof(dev_info.name)) == sizeof(dev_info.name)) {
		pr_err("kni.name not zero-terminated");
		return -EINVAL;
	}

	/**
	 * Check if the cpu core id is valid for binding.
	 */
	if (dev_info.force_bind && !cpu_online(dev_info.core_id)) {
		pr_err("cpu %u is not online\n", dev_info.core_id);
		return -EINVAL;
	}

	/* Check if it has been created */
	down_read(&knet->kni_list_lock);
	list_for_each_entry_safe(dev, n, &knet->kni_list_head, list) {
		if (kni_check_param(dev, &dev_info) < 0) {
			up_read(&knet->kni_list_lock);
			return -EINVAL;
		}
	}
	up_read(&knet->kni_list_lock);

	net_dev = alloc_netdev(sizeof(struct kni_dev), dev_info.name,
#ifdef NET_NAME_USER
							NET_NAME_USER,
#endif
							kni_net_init);
	if (net_dev == NULL) {
		pr_err("error allocating device \"%s\"\n", dev_info.name);
		return -EBUSY;
	}

	dev_net_set(net_dev, net);

	kni = netdev_priv(net_dev);

	kni->net_dev = net_dev;
	kni->group_id = dev_info.group_id;
	kni->core_id = dev_info.core_id;
	strncpy(kni->name, dev_info.name, RTE_KNI_NAMESIZE);

	/* Translate user space info into kernel space info */
	kni->tx_q = phys_to_virt(dev_info.tx_phys);
	kni->rx_q = phys_to_virt(dev_info.rx_phys);
	kni->alloc_q = phys_to_virt(dev_info.alloc_phys);
	kni->free_q = phys_to_virt(dev_info.free_phys);

	kni->req_q = phys_to_virt(dev_info.req_phys);
	kni->resp_q = phys_to_virt(dev_info.resp_phys);
	kni->sync_va = dev_info.sync_va;
	kni->sync_kva = phys_to_virt(dev_info.sync_phys);

	kni->mbuf_size = dev_info.mbuf_size;

	pr_debug("tx_phys:      0x%016llx, tx_q addr:      0x%p\n",
		(unsigned long long) dev_info.tx_phys, kni->tx_q);
	pr_debug("rx_phys:      0x%016llx, rx_q addr:      0x%p\n",
		(unsigned long long) dev_info.rx_phys, kni->rx_q);
	pr_debug("alloc_phys:   0x%016llx, alloc_q addr:   0x%p\n",
		(unsigned long long) dev_info.alloc_phys, kni->alloc_q);
	pr_debug("free_phys:    0x%016llx, free_q addr:    0x%p\n",
		(unsigned long long) dev_info.free_phys, kni->free_q);
	pr_debug("req_phys:     0x%016llx, req_q addr:     0x%p\n",
		(unsigned long long) dev_info.req_phys, kni->req_q);
	pr_debug("resp_phys:    0x%016llx, resp_q addr:    0x%p\n",
		(unsigned long long) dev_info.resp_phys, kni->resp_q);
	pr_debug("mbuf_size:    %u\n", kni->mbuf_size);

	pr_debug("PCI: %02x:%02x.%02x %04x:%04x\n",
					dev_info.bus,
					dev_info.devid,
					dev_info.function,
					dev_info.vendor_id,
					dev_info.device_id);
#ifdef RTE_KNI_KMOD_ETHTOOL
	pci = pci_get_device(dev_info.vendor_id, dev_info.device_id, NULL);

	/* Support Ethtool */
	while (pci) {
		pr_debug("pci_bus: %02x:%02x:%02x\n",
					pci->bus->number,
					PCI_SLOT(pci->devfn),
					PCI_FUNC(pci->devfn));

		if ((pci->bus->number == dev_info.bus) &&
			(PCI_SLOT(pci->devfn) == dev_info.devid) &&
			(PCI_FUNC(pci->devfn) == dev_info.function)) {
			found_pci = pci;

			if (pci_match_id(ixgbe_pci_tbl, found_pci))
				ret = ixgbe_kni_probe(found_pci, &lad_dev);
			else if (pci_match_id(igb_pci_tbl, found_pci))
				ret = igb_kni_probe(found_pci, &lad_dev);
			else
				ret = -1;

			pr_debug("PCI found: pci=0x%p, lad_dev=0x%p\n",
							pci, lad_dev);
			if (ret == 0) {
				kni->lad_dev = lad_dev;
				kni_set_ethtool_ops(kni->net_dev);
			} else {
				pr_err("Device not supported by ethtool");
				kni->lad_dev = NULL;
			}

			kni->pci_dev = found_pci;
			kni->device_id = dev_info.device_id;
			break;
		}
		pci = pci_get_device(dev_info.vendor_id,
				dev_info.device_id, pci);
	}
	if (pci)
		pci_dev_put(pci);
#endif

	if (kni->lad_dev)
		ether_addr_copy(net_dev->dev_addr, kni->lad_dev->dev_addr);
	else
		/*
		 * Generate random mac address. eth_random_addr() is the newer
		 * version of generating mac address in linux kernel.
		 */
		random_ether_addr(net_dev->dev_addr);

	ret = register_netdev(net_dev);
	if (ret) {
		pr_err("error %i registering device \"%s\"\n",
					ret, dev_info.name);
		kni->net_dev = NULL;
		kni_dev_remove(kni);
		free_netdev(net_dev);
		return -ENODEV;
	}

	ret = kni_run_thread(knet, kni, dev_info.force_bind);
	if (ret != 0)
		return ret;

	down_write(&knet->kni_list_lock);
	list_add(&kni->list, &knet->kni_list_head);
	up_write(&knet->kni_list_lock);

	return 0;
}

static int
kni_ioctl_release(struct net *net, uint32_t ioctl_num,
		unsigned long ioctl_param)
{
	struct kni_net *knet = net_generic(net, kni_net_id);
	int ret = -EINVAL;
	struct kni_dev *dev, *n;
	struct rte_kni_device_info dev_info;

	if (_IOC_SIZE(ioctl_num) > sizeof(dev_info))
		return -EINVAL;

	ret = copy_from_user(&dev_info, (void *)ioctl_param, sizeof(dev_info));
	if (ret) {
		pr_err("copy_from_user in kni_ioctl_release");
		return -EIO;
	}

	/* Release the network device according to its name */
	if (strlen(dev_info.name) == 0)
		return ret;

	down_write(&knet->kni_list_lock);
	list_for_each_entry_safe(dev, n, &knet->kni_list_head, list) {
		if (strncmp(dev->name, dev_info.name, RTE_KNI_NAMESIZE) != 0)
			continue;

		if (multiple_kthread_on && dev->pthread != NULL) {
			kthread_stop(dev->pthread);
			dev->pthread = NULL;
		}

		kni_dev_remove(dev);
		list_del(&dev->list);
		ret = 0;
		break;
	}
	up_write(&knet->kni_list_lock);
	pr_info("%s release kni named %s\n",
		(ret == 0 ? "Successfully" : "Unsuccessfully"), dev_info.name);

	return ret;
}

static int
kni_ioctl(struct inode *inode, uint32_t ioctl_num, unsigned long ioctl_param)
{
	int ret = -EINVAL;
	struct net *net = current->nsproxy->net_ns;

	pr_debug("IOCTL num=0x%0x param=0x%0lx\n", ioctl_num, ioctl_param);

	/*
	 * Switch according to the ioctl called
	 */
	switch (_IOC_NR(ioctl_num)) {
	case _IOC_NR(RTE_KNI_IOCTL_TEST):
		/* For test only, not used */
		break;
	case _IOC_NR(RTE_KNI_IOCTL_CREATE):
		ret = kni_ioctl_create(net, ioctl_num, ioctl_param);
		break;
	case _IOC_NR(RTE_KNI_IOCTL_RELEASE):
		ret = kni_ioctl_release(net, ioctl_num, ioctl_param);
		break;
	default:
		pr_debug("IOCTL default\n");
		break;
	}

	return ret;
}

static int
kni_compat_ioctl(struct inode *inode, uint32_t ioctl_num,
		unsigned long ioctl_param)
{
	/* 32 bits app on 64 bits OS to be supported later */
	pr_debug("Not implemented.\n");

	return -EINVAL;
}

static const struct file_operations kni_fops = {
	.owner = THIS_MODULE,
	.open = kni_open,
	.release = kni_release,
	.unlocked_ioctl = (void *)kni_ioctl,
	.compat_ioctl = (void *)kni_compat_ioctl,
};

static struct miscdevice kni_misc = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = KNI_DEVICE,
	.fops = &kni_fops,
};

static int __init
kni_parse_kthread_mode(void)
{
	if (!kthread_mode)
		return 0;

	if (strcmp(kthread_mode, "single") == 0)
		return 0;
	else if (strcmp(kthread_mode, "multiple") == 0)
		multiple_kthread_on = 1;
	else
		return -1;

	return 0;
}

static int __init
kni_init(void)
{
	int rc;

	if (kni_parse_kthread_mode() < 0) {
		pr_err("Invalid parameter for kthread_mode\n");
		return -EINVAL;
	}

	if (multiple_kthread_on == 0)
		pr_debug("Single kernel thread for all KNI devices\n");
	else
		pr_debug("Multiple kernel thread mode enabled\n");

#ifdef HAVE_SIMPLIFIED_PERNET_OPERATIONS
	rc = register_pernet_subsys(&kni_net_ops);
#else
	rc = register_pernet_gen_subsys(&kni_net_id, &kni_net_ops);
#endif
	if (rc)
		return -EPERM;

	rc = misc_register(&kni_misc);
	if (rc != 0) {
		pr_err("Misc registration failed\n");
		goto out;
	}

	/* Configure the lo mode according to the input parameter */
	kni_net_config_lo_mode(lo_mode);

	return 0;

out:
#ifdef HAVE_SIMPLIFIED_PERNET_OPERATIONS
	unregister_pernet_subsys(&kni_net_ops);
#else
	unregister_pernet_gen_subsys(kni_net_id, &kni_net_ops);
#endif
	return rc;
}

static void __exit
kni_exit(void)
{
	misc_deregister(&kni_misc);
#ifdef HAVE_SIMPLIFIED_PERNET_OPERATIONS
	unregister_pernet_subsys(&kni_net_ops);
#else
	unregister_pernet_gen_subsys(kni_net_id, &kni_net_ops);
#endif
}

module_init(kni_init);
module_exit(kni_exit);

module_param(lo_mode, charp, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(lo_mode,
"KNI loopback mode (default=lo_mode_none):\n"
"    lo_mode_none        Kernel loopback disabled\n"
"    lo_mode_fifo        Enable kernel loopback with fifo\n"
"    lo_mode_fifo_skb    Enable kernel loopback with fifo and skb buffer\n"
"\n"
);

module_param(kthread_mode, charp, S_IRUGO);
MODULE_PARM_DESC(kthread_mode,
"Kernel thread mode (default=single):\n"
"    single    Single kernel thread mode enabled.\n"
"    multiple  Multiple kernel thread mode enabled.\n"
"\n"
);


text:
using namespace Jelly;

JellyScene::JellyScene()
	: objects()
{

}

JellyScene::~JellyScene()
{

}

void JellyScene::Update()
{
	JellyObjectList::const_iterator it = Objects().begin();

	while (it != Objects().end())
	{
		JellyObject* object = (*it);
		object->Update();
		it++;
	}
}

redpajama_set_name: RedPajamaGithub


text:
package de.daxu.swamp.scheduling.command.build;

import de.daxu.swamp.common.axon.EventListener;
import de.daxu.swamp.scheduling.command.containerinstance.event.ContainerInstanceStatusChangedEvent;
import de.daxu.swamp.scheduling.command.project.event.BuildScheduledEvent;
import org.axonframework.eventhandling.annotation.EventHandler;
import org.springframework.beans.factory.annotation.Autowired;

@SuppressWarnings("unused")
@EventListener(replayable = false)
public class BuildProcessManager {

    private final BuildCommandService buildCommandService;

    @Autowired
    public BuildProcessManager(BuildCommandService buildCommandService) {
        this.buildCommandService = buildCommandService;
    }

    @EventHandler
    public void on(BuildScheduledEvent event) {
        buildCommandService.createBuild(
                event.getProjectId(),
                event.getSequence(),
                event.getContainerTemplates());
    }

    @EventHandler
    public void on(ContainerInstanceStatusChangedEvent event) {
        buildCommandService.updateContainerInstanceStatus(
                event.getBuildId(),
                event.getContainerInstanceId(),
                event.getContainerInstanceStatus());
    }
}


text:
#include <linux/fs.h>
#include <linux/ext2_fs.h>
#include <linux/blockgroup_lock.h>
#include <linux/percpu_counter.h>
#include <linux/rbtree.h>

/* XXX Here for now... not interested in restructing headers JUST now */

/* data type for block offset of block group */
typedef int ext2_grpblk_t;

/* data type for filesystem-wide blocks number */
typedef unsigned long ext2_fsblk_t;

#define E2FSBLK "%lu"

struct ext2_reserve_window {
	ext2_fsblk_t		_rsv_start;	/* First byte reserved */
	ext2_fsblk_t		_rsv_end;	/* Last byte reserved or 0 */
};

struct ext2_reserve_window_node {
	struct rb_node	 	rsv_node;
	__u32			rsv_goal_size;
	__u32			rsv_alloc_hit;
	struct ext2_reserve_window	rsv_window;
};

struct ext2_block_alloc_info {
	/* information about reservation window */
	struct ext2_reserve_window_node	rsv_window_node;
	/*
	 * was i_next_alloc_block in ext2_inode_info
	 * is the logical (file-relative) number of the
	 * most-recently-allocated block in this file.
	 * We use this for detecting linearly ascending allocation requests.
	 */
	__u32			last_alloc_logical_block;
	/*
	 * Was i_next_alloc_goal in ext2_inode_info
	 * is the *physical* companion to i_next_alloc_block.
	 * it the the physical block number of the block which was most-recentl
	 * allocated to this file.  This give us the goal (target) for the next
	 * allocation when we detect linearly ascending requests.
	 */
	ext2_fsblk_t		last_alloc_physical_block;
};

#define rsv_start rsv_window._rsv_start
#define rsv_end rsv_window._rsv_end

/*
 * second extended-fs super-block data in memory
 */
struct ext2_sb_info {
	unsigned long s_frag_size;	/* Size of a fragment in bytes */
	unsigned long s_frags_per_block;/* Number of fragments per block */
	unsigned long s_inodes_per_block;/* Number of inodes per block */
	unsigned long s_frags_per_group;/* Number of fragments in a group */
	unsigned long s_blocks_per_group;/* Number of blocks in a group */
	unsigned long s_inodes_per_group;/* Number of inodes in a group */
	unsigned long s_itb_per_group;	/* Number of inode table blocks per group */
	unsigned long s_gdb_count;	/* Number of group descriptor blocks */
	unsigned long s_desc_per_block;	/* Number of group descriptors per block */
	unsigned long s_groups_count;	/* Number of groups in the fs */
	unsigned long s_overhead_last;  /* Last calculated overhead */
	unsigned long s_blocks_last;    /* Last seen block count */
	struct buffer_head * s_sbh;	/* Buffer containing the super block */
	struct ext2_super_block * s_es;	/* Pointer to the super block in the buffer */
	struct buffer_head ** s_group_desc;
	unsigned long  s_mount_opt;
	unsigned long s_sb_block;
	uid_t s_resuid;
	gid_t s_resgid;
	unsigned short s_mount_state;
	unsigned short s_pad;
	int s_addr_per_block_bits;
	int s_desc_per_block_bits;
	int s_inode_size;
	int s_first_ino;
	spinlock_t s_next_gen_lock;
	u32 s_next_generation;
	unsigned long s_dir_count;
	u8 *s_debts;
	struct percpu_counter s_freeblocks_counter;
	struct percpu_counter s_freeinodes_counter;
	struct percpu_counter s_dirs_counter;
	struct blockgroup_lock *s_blockgroup_lock;
	/* root of the per fs reservation window tree */
	spinlock_t s_rsv_window_lock;
	struct rb_root s_rsv_window_root;
	struct ext2_reserve_window_node s_rsv_window_head;
	/*
	 * s_lock protects against concurrent modifications of s_mount_state,
	 * s_blocks_last, s_overhead_last and the content of superblock's
	 * buffer pointed to by sbi->s_es.
	 *
	 * Note: It is used in ext2_show_options() to provide a consistent view
	 * of the mount options.
	 */
	spinlock_t s_lock;
};

static inline spinlock_t *
sb_bgl_lock(struct ext2_sb_info *sbi, unsigned int block_group)
{
	return bgl_lock_ptr(sbi->s_blockgroup_lock, block_group);
}

/*
 * Define EXT2FS_DEBUG to produce debug messages
 */
#undef EXT2FS_DEBUG

/*
 * Define EXT2_RESERVATION to reserve data blocks for expanding files
 */
#define EXT2_DEFAULT_RESERVE_BLOCKS     8
/*max window size: 1024(direct blocks) + 3([t,d]indirect blocks) */
#define EXT2_MAX_RESERVE_BLOCKS         1027
#define EXT2_RESERVE_WINDOW_NOT_ALLOCATED 0
/*
 * The second extended file system version
 */
#define EXT2FS_DATE		"95/08/09"
#define EXT2FS_VERSION		"0.5b"

/*
 * Debug code
 */
#ifdef EXT2FS_DEBUG
#	define ext2_debug(f, a...)	{ \
					printk ("EXT2-fs DEBUG (%s, %d): %s:", \
						__FILE__, __LINE__, __func__); \
				  	printk (f, ## a); \
					}
#else
#	define ext2_debug(f, a...)	/**/
#endif

/*
 * Special inode numbers
 */
#define	EXT2_BAD_INO		 1	/* Bad blocks inode */
#define EXT2_ROOT_INO		 2	/* Root inode */
#define EXT2_BOOT_LOADER_INO	 5	/* Boot loader inode */
#define EXT2_UNDEL_DIR_INO	 6	/* Undelete directory inode */

/* First non-reserved inode for old ext2 filesystems */
#define EXT2_GOOD_OLD_FIRST_INO	11

static inline struct ext2_sb_info *EXT2_SB(struct super_block *sb)
{
	return sb->s_fs_info;
}

/*
 * Macro-instructions used to manage several block sizes
 */
#define EXT2_MIN_BLOCK_SIZE		1024
#define	EXT2_MAX_BLOCK_SIZE		4096
#define EXT2_MIN_BLOCK_LOG_SIZE		  10
#define EXT2_BLOCK_SIZE(s)		((s)->s_blocksize)
#define	EXT2_ADDR_PER_BLOCK(s)		(EXT2_BLOCK_SIZE(s) / sizeof (__u32))
#define EXT2_BLOCK_SIZE_BITS(s)		((s)->s_blocksize_bits)
#define	EXT2_ADDR_PER_BLOCK_BITS(s)	(EXT2_SB(s)->s_addr_per_block_bits)
#define EXT2_INODE_SIZE(s)		(EXT2_SB(s)->s_inode_size)
#define EXT2_FIRST_INO(s)		(EXT2_SB(s)->s_first_ino)

/*
 * Macro-instructions used to manage fragments
 */
#define EXT2_MIN_FRAG_SIZE		1024
#define	EXT2_MAX_FRAG_SIZE		4096
#define EXT2_MIN_FRAG_LOG_SIZE		  10
#define EXT2_FRAG_SIZE(s)		(EXT2_SB(s)->s_frag_size)
#define EXT2_FRAGS_PER_BLOCK(s)		(EXT2_SB(s)->s_frags_per_block)

/*
 * Structure of a blocks group descriptor
 */
struct ext2_group_desc
{
	__le32	bg_block_bitmap;		/* Blocks bitmap block */
	__le32	bg_inode_bitmap;		/* Inodes bitmap block */
	__le32	bg_inode_table;		/* Inodes table block */
	__le16	bg_free_blocks_count;	/* Free blocks count */
	__le16	bg_free_inodes_count;	/* Free inodes count */
	__le16	bg_used_dirs_count;	/* Directories count */
	__le16	bg_pad;
	__le32	bg_reserved[3];
};

/*
 * Macro-instructions used to manage group descriptors
 */
#define EXT2_BLOCKS_PER_GROUP(s)	(EXT2_SB(s)->s_blocks_per_group)
#define EXT2_DESC_PER_BLOCK(s)		(EXT2_SB(s)->s_desc_per_block)
#define EXT2_INODES_PER_GROUP(s)	(EXT2_SB(s)->s_inodes_per_group)
#define EXT2_DESC_PER_BLOCK_BITS(s)	(EXT2_SB(s)->s_desc_per_block_bits)

/*
 * Constants relative to the data blocks
 */
#define	EXT2_NDIR_BLOCKS		12
#define	EXT2_IND_BLOCK			EXT2_NDIR_BLOCKS
#define	EXT2_DIND_BLOCK			(EXT2_IND_BLOCK + 1)
#define	EXT2_TIND_BLOCK			(EXT2_DIND_BLOCK + 1)
#define	EXT2_N_BLOCKS			(EXT2_TIND_BLOCK + 1)

/*
 * Inode flags (GETFLAGS/SETFLAGS)
 */
#define	EXT2_SECRM_FL			FS_SECRM_FL	/* Secure deletion */
#define	EXT2_UNRM_FL			FS_UNRM_FL	/* Undelete */
#define	EXT2_COMPR_FL			FS_COMPR_FL	/* Compress file */
#define EXT2_SYNC_FL			FS_SYNC_FL	/* Synchronous updates */
#define EXT2_IMMUTABLE_FL		FS_IMMUTABLE_FL	/* Immutable file */
#define EXT2_APPEND_FL			FS_APPEND_FL	/* writes to file may only append */
#define EXT2_NODUMP_FL			FS_NODUMP_FL	/* do not dump file */
#define EXT2_NOATIME_FL			FS_NOATIME_FL	/* do not update atime */
/* Reserved for compression usage... */
#define EXT2_DIRTY_FL			FS_DIRTY_FL
#define EXT2_COMPRBLK_FL		FS_COMPRBLK_FL	/* One or more compressed clusters */
#define EXT2_NOCOMP_FL			FS_NOCOMP_FL	/* Don't compress */
#define EXT2_ECOMPR_FL			FS_ECOMPR_FL	/* Compression error */
/* End compression flags --- maybe not all used */
#define EXT2_BTREE_FL			FS_BTREE_FL	/* btree format dir */
#define EXT2_INDEX_FL			FS_INDEX_FL	/* hash-indexed directory */
#define EXT2_IMAGIC_FL			FS_IMAGIC_FL	/* AFS directory */
#define EXT2_JOURNAL_DATA_FL		FS_JOURNAL_DATA_FL /* Reserved for ext3 */
#define EXT2_NOTAIL_FL			FS_NOTAIL_FL	/* file tail should not be merged */
#define EXT2_DIRSYNC_FL			FS_DIRSYNC_FL	/* dirsync behaviour (directories only) */
#define EXT2_TOPDIR_FL			FS_TOPDIR_FL	/* Top of directory hierarchies*/
#define EXT2_RESERVED_FL		FS_RESERVED_FL	/* reserved for ext2 lib */

#define EXT2_FL_USER_VISIBLE		FS_FL_USER_VISIBLE	/* User visible flags */
#define EXT2_FL_USER_MODIFIABLE		FS_FL_USER_MODIFIABLE	/* User modifiable flags */

/* Flags that should be inherited by new inodes from their parent. */
#define EXT2_FL_INHERITED (EXT2_SECRM_FL | EXT2_UNRM_FL | EXT2_COMPR_FL |\
			   EXT2_SYNC_FL | EXT2_NODUMP_FL |\
			   EXT2_NOATIME_FL | EXT2_COMPRBLK_FL |\
			   EXT2_NOCOMP_FL | EXT2_JOURNAL_DATA_FL |\
			   EXT2_NOTAIL_FL | EXT2_DIRSYNC_FL)

/* Flags that are appropriate for regular files (all but dir-specific ones). */
#define EXT2_REG_FLMASK (~(EXT2_DIRSYNC_FL | EXT2_TOPDIR_FL))

/* Flags that are appropriate for non-directories/regular files. */
#define EXT2_OTHER_FLMASK (EXT2_NODUMP_FL | EXT2_NOATIME_FL)

/* Mask out flags that are inappropriate for the given type of inode. */
static inline __u32 ext2_mask_flags(umode_t mode, __u32 flags)
{
	if (S_ISDIR(mode))
		return flags;
	else if (S_ISREG(mode))
		return flags & EXT2_REG_FLMASK;
	else
		return flags & EXT2_OTHER_FLMASK;
}

/*
 * ioctl commands
 */
#define	EXT2_IOC_GETFLAGS		FS_IOC_GETFLAGS
#define	EXT2_IOC_SETFLAGS		FS_IOC_SETFLAGS
#define	EXT2_IOC_GETVERSION		FS_IOC_GETVERSION
#define	EXT2_IOC_SETVERSION		FS_IOC_SETVERSION
#define	EXT2_IOC_GETRSVSZ		_IOR('f', 5, long)
#define	EXT2_IOC_SETRSVSZ		_IOW('f', 6, long)

/*
 * ioctl commands in 32 bit emulation
 */
#define EXT2_IOC32_GETFLAGS		FS_IOC32_GETFLAGS
#define EXT2_IOC32_SETFLAGS		FS_IOC32_SETFLAGS
#define EXT2_IOC32_GETVERSION		FS_IOC32_GETVERSION
#define EXT2_IOC32_SETVERSION		FS_IOC32_SETVERSION

/*
 * Structure of an inode on the disk
 */
struct ext2_inode {
	__le16	i_mode;		/* File mode */
	__le16	i_uid;		/* Low 16 bits of Owner Uid */
	__le32	i_size;		/* Size in bytes */
	__le32	i_atime;	/* Access time */
	__le32	i_ctime;	/* Creation time */
	__le32	i_mtime;	/* Modification time */
	__le32	i_dtime;	/* Deletion Time */
	__le16	i_gid;		/* Low 16 bits of Group Id */
	__le16	i_links_count;	/* Links count */
	__le32	i_blocks;	/* Blocks count */
	__le32	i_flags;	/* File flags */
	union {
		struct {
			__le32  l_i_reserved1;
		} linux1;
		struct {
			__le32  h_i_translator;
		} hurd1;
		struct {
			__le32  m_i_reserved1;
		} masix1;
	} osd1;				/* OS dependent 1 */
	__le32	i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
	__le32	i_generation;	/* File version (for NFS) */
	__le32	i_file_acl;	/* File ACL */
	__le32	i_dir_acl;	/* Directory ACL */
	__le32	i_faddr;	/* Fragment address */
	union {
		struct {
			__u8	l_i_frag;	/* Fragment number */
			__u8	l_i_fsize;	/* Fragment size */
			__u16	i_pad1;
			__le16	l_i_uid_high;	/* these 2 fields    */
			__le16	l_i_gid_high;	/* were reserved2[0] */
			__u32	l_i_reserved2;
		} linux2;
		struct {
			__u8	h_i_frag;	/* Fragment number */
			__u8	h_i_fsize;	/* Fragment size */
			__le16	h_i_mode_high;
			__le16	h_i_uid_high;
			__le16	h_i_gid_high;
			__le32	h_i_author;
		} hurd2;
		struct {
			__u8	m_i_frag;	/* Fragment number */
			__u8	m_i_fsize;	/* Fragment size */
			__u16	m_pad1;
			__u32	m_i_reserved2[2];
		} masix2;
	} osd2;				/* OS dependent 2 */
};

#define i_size_high	i_dir_acl

#define i_reserved1	osd1.linux1.l_i_reserved1
#define i_frag		osd2.linux2.l_i_frag
#define i_fsize		osd2.linux2.l_i_fsize
#define i_uid_low	i_uid
#define i_gid_low	i_gid
#define i_uid_high	osd2.linux2.l_i_uid_high
#define i_gid_high	osd2.linux2.l_i_gid_high
#define i_reserved2	osd2.linux2.l_i_reserved2

/*
 * File system states
 */
#define	EXT2_VALID_FS			0x0001	/* Unmounted cleanly */
#define	EXT2_ERROR_FS			0x0002	/* Errors detected */

/*
 * Mount flags
 */
#define EXT2_MOUNT_CHECK		0x000001  /* Do mount-time checks */
#define EXT2_MOUNT_OLDALLOC		0x000002  /* Don't use the new Orlov allocator */
#define EXT2_MOUNT_GRPID		0x000004  /* Create files with directory's group */
#define EXT2_MOUNT_DEBUG		0x000008  /* Some debugging messages */
#define EXT2_MOUNT_ERRORS_CONT		0x000010  /* Continue on errors */
#define EXT2_MOUNT_ERRORS_RO		0x000020  /* Remount fs ro on errors */
#define EXT2_MOUNT_ERRORS_PANIC		0x000040  /* Panic on errors */
#define EXT2_MOUNT_MINIX_DF		0x000080  /* Mimics the Minix statfs */
#define EXT2_MOUNT_NOBH			0x000100  /* No buffer_heads */
#define EXT2_MOUNT_NO_UID32		0x000200  /* Disable 32-bit UIDs */
#define EXT2_MOUNT_XATTR_USER		0x004000  /* Extended user attributes */
#define EXT2_MOUNT_POSIX_ACL		0x008000  /* POSIX Access Control Lists */
#define EXT2_MOUNT_XIP			0x010000  /* Execute in place */
#define EXT2_MOUNT_USRQUOTA		0x020000  /* user quota */
#define EXT2_MOUNT_GRPQUOTA		0x040000  /* group quota */
#define EXT2_MOUNT_RESERVATION		0x080000  /* Preallocation */

#define clear_opt(o, opt)		o &= ~EXT2_MOUNT_##opt
#define set_opt(o, opt)			o |= EXT2_MOUNT_##opt
#define test_opt(sb, opt)		(EXT2_SB(sb)->s_mount_opt & \
					 EXT2_MOUNT_##opt)
/*
 * Maximal mount counts between two filesystem checks
 */
#define EXT2_DFL_MAX_MNT_COUNT		20	/* Allow 20 mounts */
#define EXT2_DFL_CHECKINTERVAL		0	/* Don't use interval check */

/*
 * Behaviour when detecting errors
 */
#define EXT2_ERRORS_CONTINUE		1	/* Continue execution */
#define EXT2_ERRORS_RO			2	/* Remount fs read-only */
#define EXT2_ERRORS_PANIC		3	/* Panic */
#define EXT2_ERRORS_DEFAULT		EXT2_ERRORS_CONTINUE

/*
 * Structure of the super block
 */
struct ext2_super_block {
	__le32	s_inodes_count;		/* Inodes count */
	__le32	s_blocks_count;		/* Blocks count */
	__le32	s_r_blocks_count;	/* Reserved blocks count */
	__le32	s_free_blocks_count;	/* Free blocks count */
	__le32	s_free_inodes_count;	/* Free inodes count */
	__le32	s_first_data_block;	/* First Data Block */
	__le32	s_log_block_size;	/* Block size */
	__le32	s_log_frag_size;	/* Fragment size */
	__le32	s_blocks_per_group;	/* # Blocks per group */
	__le32	s_frags_per_group;	/* # Fragments per group */
	__le32	s_inodes_per_group;	/* # Inodes per group */
	__le32	s_mtime;		/* Mount time */
	__le32	s_wtime;		/* Write time */
	__le16	s_mnt_count;		/* Mount count */
	__le16	s_max_mnt_count;	/* Maximal mount count */
	__le16	s_magic;		/* Magic signature */
	__le16	s_state;		/* File system state */
	__le16	s_errors;		/* Behaviour when detecting errors */
	__le16	s_minor_rev_level; 	/* minor revision level */
	__le32	s_lastcheck;		/* time of last check */
	__le32	s_checkinterval;	/* max. time between checks */
	__le32	s_creator_os;		/* OS */
	__le32	s_rev_level;		/* Revision level */
	__le16	s_def_resuid;		/* Default uid for reserved blocks */
	__le16	s_def_resgid;		/* Default gid for reserved blocks */
	/*
	 * These fields are for EXT2_DYNAMIC_REV superblocks only.
	 *
	 * Note: the difference between the compatible feature set and
	 * the incompatible feature set is that if there is a bit set
	 * in the incompatible feature set that the kernel doesn't
	 * know about, it should refuse to mount the filesystem.
	 *
	 * e2fsck's requirements are more strict; if it doesn't know
	 * about a feature in either the compatible or incompatible
	 * feature set, it must abort and not try to meddle with
	 * things it doesn't understand...
	 */
	__le32	s_first_ino; 		/* First non-reserved inode */
	__le16   s_inode_size; 		/* size of inode structure */
	__le16	s_block_group_nr; 	/* block group # of this superblock */
	__le32	s_feature_compat; 	/* compatible feature set */
	__le32	s_feature_incompat; 	/* incompatible feature set */
	__le32	s_feature_ro_compat; 	/* readonly-compatible feature set */
	__u8	s_uuid[16];		/* 128-bit uuid for volume */
	char	s_volume_name[16]; 	/* volume name */
	char	s_last_mounted[64]; 	/* directory where last mounted */
	__le32	s_algorithm_usage_bitmap; /* For compression */
	/*
	 * Performance hints.  Directory preallocation should only
	 * happen if the EXT2_COMPAT_PREALLOC flag is on.
	 */
	__u8	s_prealloc_blocks;	/* Nr of blocks to try to preallocate*/
	__u8	s_prealloc_dir_blocks;	/* Nr to preallocate for dirs */
	__u16	s_padding1;
	/*
	 * Journaling support valid if EXT3_FEATURE_COMPAT_HAS_JOURNAL set.
	 */
	__u8	s_journal_uuid[16];	/* uuid of journal superblock */
	__u32	s_journal_inum;		/* inode number of journal file */
	__u32	s_journal_dev;		/* device number of journal file */
	__u32	s_last_orphan;		/* start of list of inodes to delete */
	__u32	s_hash_seed[4];		/* HTREE hash seed */
	__u8	s_def_hash_version;	/* Default hash version to use */
	__u8	s_reserved_char_pad;
	__u16	s_reserved_word_pad;
	__le32	s_default_mount_opts;
 	__le32	s_first_meta_bg; 	/* First metablock block group */
	__u32	s_reserved[190];	/* Padding to the end of the block */
};

/*
 * Codes for operating systems
 */
#define EXT2_OS_LINUX		0
#define EXT2_OS_HURD		1
#define EXT2_OS_MASIX		2
#define EXT2_OS_FREEBSD		3
#define EXT2_OS_LITES		4

/*
 * Revision levels
 */
#define EXT2_GOOD_OLD_REV	0	/* The good old (original) format */
#define EXT2_DYNAMIC_REV	1 	/* V2 format w/ dynamic inode sizes */

#define EXT2_CURRENT_REV	EXT2_GOOD_OLD_REV
#define EXT2_MAX_SUPP_REV	EXT2_DYNAMIC_REV

#define EXT2_GOOD_OLD_INODE_SIZE 128

/*
 * Feature set definitions
 */

#define EXT2_HAS_COMPAT_FEATURE(sb,mask)			\
	( EXT2_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask) )
#define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask)			\
	( EXT2_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask) )
#define EXT2_HAS_INCOMPAT_FEATURE(sb,mask)			\
	( EXT2_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask) )
#define EXT2_SET_COMPAT_FEATURE(sb,mask)			\
	EXT2_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
#define EXT2_SET_RO_COMPAT_FEATURE(sb,mask)			\
	EXT2_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
#define EXT2_SET_INCOMPAT_FEATURE(sb,mask)			\
	EXT2_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
#define EXT2_CLEAR_COMPAT_FEATURE(sb,mask)			\
	EXT2_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
#define EXT2_CLEAR_RO_COMPAT_FEATURE(sb,mask)			\
	EXT2_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
#define EXT2_CLEAR_INCOMPAT_FEATURE(sb,mask)			\
	EXT2_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)

#define EXT2_FEATURE_COMPAT_DIR_PREALLOC	0x0001
#define EXT2_FEATURE_COMPAT_IMAGIC_INODES	0x0002
#define EXT3_FEATURE_COMPAT_HAS_JOURNAL		0x0004
#define EXT2_FEATURE_COMPAT_EXT_ATTR		0x0008
#define EXT2_FEATURE_COMPAT_RESIZE_INO		0x0010
#define EXT2_FEATURE_COMPAT_DIR_INDEX		0x0020
#define EXT2_FEATURE_COMPAT_ANY			0xffffffff

#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER	0x0001
#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE	0x0002
#define EXT2_FEATURE_RO_COMPAT_BTREE_DIR	0x0004
#define EXT2_FEATURE_RO_COMPAT_ANY		0xffffffff

#define EXT2_FEATURE_INCOMPAT_COMPRESSION	0x0001
#define EXT2_FEATURE_INCOMPAT_FILETYPE		0x0002
#define EXT3_FEATURE_INCOMPAT_RECOVER		0x0004
#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV	0x0008
#define EXT2_FEATURE_INCOMPAT_META_BG		0x0010
#define EXT2_FEATURE_INCOMPAT_ANY		0xffffffff

#define EXT2_FEATURE_COMPAT_SUPP	EXT2_FEATURE_COMPAT_EXT_ATTR
#define EXT2_FEATURE_INCOMPAT_SUPP	(EXT2_FEATURE_INCOMPAT_FILETYPE| \
					 EXT2_FEATURE_INCOMPAT_META_BG)
#define EXT2_FEATURE_RO_COMPAT_SUPP	(EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \
					 EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
					 EXT2_FEATURE_RO_COMPAT_BTREE_DIR)
#define EXT2_FEATURE_RO_COMPAT_UNSUPPORTED	~EXT2_FEATURE_RO_COMPAT_SUPP
#define EXT2_FEATURE_INCOMPAT_UNSUPPORTED	~EXT2_FEATURE_INCOMPAT_SUPP

/*
 * Default values for user and/or group using reserved blocks
 */
#define	EXT2_DEF_RESUID		0
#define	EXT2_DEF_RESGID		0

/*
 * Default mount options
 */
#define EXT2_DEFM_DEBUG		0x0001
#define EXT2_DEFM_BSDGROUPS	0x0002
#define EXT2_DEFM_XATTR_USER	0x0004
#define EXT2_DEFM_ACL		0x0008
#define EXT2_DEFM_UID16		0x0010
    /* Not used by ext2, but reserved for use by ext3 */
#define EXT3_DEFM_JMODE		0x0060
#define EXT3_DEFM_JMODE_DATA	0x0020
#define EXT3_DEFM_JMODE_ORDERED	0x0040
#define EXT3_DEFM_JMODE_WBACK	0x0060

/*
 * Structure of a directory entry
 */

struct ext2_dir_entry {
	__le32	inode;			/* Inode number */
	__le16	rec_len;		/* Directory entry length */
	__le16	name_len;		/* Name length */
	char	name[];			/* File name, up to EXT2_NAME_LEN */
};

/*
 * The new version of the directory entry.  Since EXT2 structures are
 * stored in intel byte order, and the name_len field could never be
 * bigger than 255 chars, it's safe to reclaim the extra byte for the
 * file_type field.
 */
struct ext2_dir_entry_2 {
	__le32	inode;			/* Inode number */
	__le16	rec_len;		/* Directory entry length */
	__u8	name_len;		/* Name length */
	__u8	file_type;
	char	name[];			/* File name, up to EXT2_NAME_LEN */
};

/*
 * Ext2 directory file types.  Only the low 3 bits are used.  The
 * other bits are reserved for now.
 */
enum {
	EXT2_FT_UNKNOWN		= 0,
	EXT2_FT_REG_FILE	= 1,
	EXT2_FT_DIR		= 2,
	EXT2_FT_CHRDEV		= 3,
	EXT2_FT_BLKDEV		= 4,
	EXT2_FT_FIFO		= 5,
	EXT2_FT_SOCK		= 6,
	EXT2_FT_SYMLINK		= 7,
	EXT2_FT_MAX
};

/*
 * EXT2_DIR_PAD defines the directory entries boundaries
 *
 * NOTE: It must be a multiple of 4
 */
#define EXT2_DIR_PAD		 	4
#define EXT2_DIR_ROUND 			(EXT2_DIR_PAD - 1)
#define EXT2_DIR_REC_LEN(name_len)	(((name_len) + 8 + EXT2_DIR_ROUND) & \
					 ~EXT2_DIR_ROUND)
#define EXT2_MAX_REC_LEN		((1<<16)-1)

static inline void verify_offsets(void)
{
#define A(x,y) BUILD_BUG_ON(x != offsetof(struct ext2_super_block, y));
	A(EXT2_SB_MAGIC_OFFSET, s_magic);
	A(EXT2_SB_BLOCKS_OFFSET, s_blocks_count);
	A(EXT2_SB_BSIZE_OFFSET, s_log_block_size);
#undef A
}

/*
 * ext2 mount options
 */
struct ext2_mount_options {
	unsigned long s_mount_opt;
	uid_t s_resuid;
	gid_t s_resgid;
};

/*
 * second extended file system inode data in memory
 */
struct ext2_inode_info {
	__le32	i_data[15];
	__u32	i_flags;
	__u32	i_faddr;
	__u8	i_frag_no;
	__u8	i_frag_size;
	__u16	i_state;
	__u32	i_file_acl;
	__u32	i_dir_acl;
	__u32	i_dtime;

	/*
	 * i_block_group is the number of the block group which contains
	 * this file's inode.  Constant across the lifetime of the inode,
	 * it is used for making block allocation decisions - we try to
	 * place a file's data blocks near its inode block, and new inodes
	 * near to their parent directory's inode.
	 */
	__u32	i_block_group;

	/* block reservation info */
	struct ext2_block_alloc_info *i_block_alloc_info;

	__u32	i_dir_start_lookup;
#ifdef CONFIG_EXT2_FS_XATTR
	/*
	 * Extended attributes can be read independently of the main file
	 * data. Taking i_mutex even when reading would cause contention
	 * between readers of EAs and writers of regular file data, so
	 * instead we synchronize on xattr_sem when reading or changing
	 * EAs.
	 */
	struct rw_semaphore xattr_sem;
#endif
	rwlock_t i_meta_lock;

	/*
	 * truncate_mutex is for serialising ext2_truncate() against
	 * ext2_getblock().  It also protects the internals of the inode's
	 * reservation data structures: ext2_reserve_window and
	 * ext2_reserve_window_node.
	 */
	struct mutex truncate_mutex;
	struct inode	vfs_inode;
	struct list_head i_orphan;	/* unlinked but open inodes */
};

/*
 * Inode dynamic state flags
 */
#define EXT2_STATE_NEW			0x00000001 /* inode is newly created */

/*
 * Function prototypes
 */

/*
 * Ok, these declarations are also in <linux/kernel.h> but none of the
 * ext2 source programs needs to include it so they are duplicated here.
 */

static inline struct ext2_inode_info *EXT2_I(struct inode *inode)
{
	return container_of(inode, struct ext2_inode_info, vfs_inode);
}

/* balloc.c */
extern int ext2_bg_has_super(struct super_block *sb, int group);
extern unsigned long ext2_bg_num_gdb(struct super_block *sb, int group);
extern ext2_fsblk_t ext2_new_block(struct inode *, unsigned long, int *);
extern ext2_fsblk_t ext2_new_blocks(struct inode *, unsigned long,
				unsigned long *, int *);
extern void ext2_free_blocks (struct inode *, unsigned long,
			      unsigned long);
extern unsigned long ext2_count_free_blocks (struct super_block *);
extern unsigned long ext2_count_dirs (struct super_block *);
extern void ext2_check_blocks_bitmap (struct super_block *);
extern struct ext2_group_desc * ext2_get_group_desc(struct super_block * sb,
						    unsigned int block_group,
						    struct buffer_head ** bh);
extern void ext2_discard_reservation (struct inode *);
extern int ext2_should_retry_alloc(struct super_block *sb, int *retries);
extern void ext2_init_block_alloc_info(struct inode *);
extern void ext2_rsv_window_add(struct super_block *sb, struct ext2_reserve_window_node *rsv);

/* dir.c */
extern int ext2_add_link (struct dentry *, struct inode *);
extern ino_t ext2_inode_by_name(struct inode *, struct qstr *);
extern int ext2_make_empty(struct inode *, struct inode *);
extern struct ext2_dir_entry_2 * ext2_find_entry (struct inode *,struct qstr *, struct page **);
extern int ext2_delete_entry (struct ext2_dir_entry_2 *, struct page *);
extern int ext2_empty_dir (struct inode *);
extern struct ext2_dir_entry_2 * ext2_dotdot (struct inode *, struct page **);
extern void ext2_set_link(struct inode *, struct ext2_dir_entry_2 *, struct page *, struct inode *, int);

/* ialloc.c */
extern struct inode * ext2_new_inode (struct inode *, umode_t, const struct qstr *);
extern void ext2_free_inode (struct inode *);
extern unsigned long ext2_count_free_inodes (struct super_block *);
extern void ext2_check_inodes_bitmap (struct super_block *);
extern unsigned long ext2_count_free (struct buffer_head *, unsigned);

/* inode.c */
extern struct inode *ext2_iget (struct super_block *, unsigned long);
extern int ext2_write_inode (struct inode *, struct writeback_control *);
extern void ext2_evict_inode(struct inode *);
extern int ext2_get_block(struct inode *, sector_t, struct buffer_head *, int);
extern int ext2_setattr (struct dentry *, struct iattr *);
extern void ext2_set_inode_flags(struct inode *inode);
extern void ext2_get_inode_flags(struct ext2_inode_info *);
extern int ext2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
		       u64 start, u64 len);

/* ioctl.c */
extern long ext2_ioctl(struct file *, unsigned int, unsigned long);
extern long ext2_compat_ioctl(struct file *, unsigned int, unsigned long);

/* namei.c */
struct dentry *ext2_get_parent(struct dentry *child);

/* super.c */
extern __printf(3, 4)
void ext2_error(struct super_block *, const char *, const char *, ...);
extern __printf(3, 4)
void ext2_msg(struct super_block *, const char *, const char *, ...);
extern void ext2_update_dynamic_rev (struct super_block *sb);
extern void ext2_write_super (struct super_block *);

/*
 * Inodes and files operations
 */

/* dir.c */
extern const struct file_operations ext2_dir_operations;

/* file.c */
extern int ext2_fsync(struct file *file, loff_t start, loff_t end,
		      int datasync);
extern const struct inode_operations ext2_file_inode_operations;
extern const struct file_operations ext2_file_operations;
extern const struct file_operations ext2_xip_file_operations;

/* inode.c */
extern const struct address_space_operations ext2_aops;
extern const struct address_space_operations ext2_aops_xip;
extern const struct address_space_operations ext2_nobh_aops;

/* namei.c */
extern const struct inode_operations ext2_dir_inode_operations;
extern const struct inode_operations ext2_special_inode_operations;

/* symlink.c */
extern const struct inode_operations ext2_fast_symlink_inode_operations;
extern const struct inode_operations ext2_symlink_inode_operations;

static inline ext2_fsblk_t
ext2_group_first_block_no(struct super_block *sb, unsigned long group_no)
{
	return group_no * (ext2_fsblk_t)EXT2_BLOCKS_PER_GROUP(sb) +
		le32_to_cpu(EXT2_SB(sb)->s_es->s_first_data_block);
}

#define ext2_set_bit	__test_and_set_bit_le
#define ext2_clear_bit	__test_and_clear_bit_le
#define ext2_test_bit	test_bit_le
#define ext2_find_first_zero_bit	find_first_zero_bit_le
#define ext2_find_next_zero_bit		find_next_zero_bit_le


text:
"""
h2o -- module for using H2O services.

:copyright: (c) 2016 H2O.ai
:license:   Apache License Version 2.0 (see LICENSE for details)
"""
from __future__ import absolute_import, division, print_function, unicode_literals

import tabulate

from .utils.compatibility import *  # NOQA

class H2ODisplay(object):
    """
    Pretty printing for H2O Objects.

    Handles both IPython and vanilla console display
    """
    THOUSANDS = "{:,}"

    # True/False flag whether we are connected to a Jupyter notebook. Computed on the first use.
    _jupyter = None

    def __init__(self, table=None, header=None, table_header=None, **kwargs):
        self.table_header = table_header
        self.header = header
        self.table = table
        self.kwargs = kwargs
        self.do_print = True

        # one-shot display... never return an H2ODisplay object (or try not to)
        # if holding onto a display object, then may have odd printing behavior
        # the __repr__ and _repr_html_ methods will try to save you from many prints,
        # but just be WARNED that your mileage may vary!
        #
        # In other words, it's better to just new one of these when you're ready to print out.

        if self.table_header is not None:
            print()
            print(self.table_header + ":")
            print()
        if H2ODisplay._in_ipy():
            from IPython.display import display
            display(self)
            self.do_print = False
        else:
            self.pprint()
            self.do_print = False

    # for Ipython
    def _repr_html_(self):
        if self.do_print:
            return H2ODisplay._html_table(self.table, self.header)

    def pprint(self):
        r = self.__repr__()
        print(r)

    # for python REPL console
    def __repr__(self):
        if self.do_print or not H2ODisplay._in_ipy():
            if self.header is None:
                return tabulate.tabulate(self.table, **self.kwargs)
            else:
                return tabulate.tabulate(self.table, headers=self.header, **self.kwargs)
        self.do_print = True
        return ""

    @staticmethod
    def _in_ipy():  # are we in ipy? then pretty print tables with _repr_html
        if H2ODisplay._jupyter is None:
            try:
                import IPython
                from ipykernel.zmqshell import ZMQInteractiveShell
                ipy = IPython.get_ipython()
                H2ODisplay._jupyter = isinstance(ipy, ZMQInteractiveShell)
            except ImportError:
                H2ODisplay._jupyter = False
        return H2ODisplay._jupyter

    # some html table builder helper things
    @staticmethod
    def _html_table(rows, header=None):
        # keep table in a div for scrollability
        table = "

{}

"
        table_rows = []
        if header is not None:
            table_rows.append(H2ODisplay._html_row(header, bold=True))
        for row in rows:
            table_rows.append(H2ODisplay._html_row(row))
        return table.format("\n".join(table_rows))

    @staticmethod
    def _html_row(row, bold=False):
        res = "
{}
"
        entry = "{}	" if bold else "{}	"
        # format full floating point numbers to 7 decimal places
        entries = "\n".join([entry.format(str(r))
                             if len(str(r)) < 10 or not _is_number(str(r))
                             else entry.format("{0:.7f}".format(float(str(r)))) for r in row])
        return res.format(entries)

def _is_number(s):
    try:
        float(s)
        return True
    except ValueError:
        return False


text:
using namespace std;
using namespace boost::python;
using namespace boost;
using namespace KingstarAPI;

//³£Á¿
#define ONFRONTCONNECTED 1
#define ONFRONTDISCONNECTED 2
#define ONRSPUSERLOGIN 3
#define ONRSPUSERLOGOUT 4
#define ONRSPUSERPASSWORDUPDATE 5
#define ONRSPTRADINGACCOUNTPASSWORDUPDATE 6
#define ONRSPORDERINSERT 7
#define ONRSPORDERACTION 8
#define ONRSPQRYORDER 9
#define ONRSPQRYTRADE 10
#define ONRSPQRYINVESTORPOSITION 11
#define ONRSPQRYTRADINGACCOUNT 12
#define ONRSPQRYINVESTOR 13
#define ONRSPQRYTRADINGCODE 14
#define ONRSPQRYEXCHANGE 15
#define ONRSPQRYINSTRUMENT 16
#define ONRSPQRYINVESTORPOSITIONDETAIL 17
#define ONRSPQRYTRADINGNOTICE 18
#define ONRSPEXECORDERINSERT 19
#define ONRSPLOCKINSERT 20
#define ONRSPEXECORDERACTION 21
#define ONRSPQRYEXECORDER 22
#define ONRSPQRYEXECORDERVOLUME 23
#define ONRSPQRYLOCK 24
#define ONRSPQRYLOCKPOSITION 25
#define ONRSPQRYUNDERLYINGSTOCKINFO 26
#define ONRSPQRYOTPINSCOMMRATE 27
#define ONRSPQRYINSTRUMENTMARGINRATE 28
#define ONRSPQRYOTPASSIGNMENT 29
#define ONRSPQRYDEPTHMARKETDATA 30
#define ONRSPFROMBANKTOSTOCKBYSTOCK 31
#define ONRTNFROMBANKTOSTOCKBYSTOCK 32
#define ONRSPFROMSTOCKTOBANKBYSTOCK 33
#define ONRTNFROMSTOCKTOBANKBYSTOCK 34
#define ONRTNQUERYBANKBALANCEBYSTOCK 35
#define ONRSPQRYCONTRACTBANK 36
#define ONRSPQUERYBANKACCOUNTMONEYBYSTOCK 37
#define ONRSPQRYTRANSFERSERIAL 38
#define ONRSPQRYSETTLEMENTINFOCONFIRM 39
#define ONRSPSETTLEMENTINFOCONFIRM 40
#define ONRSPQRYSETTLEMENTINFO 41
#define ONRSPQRYINVESTORTRADELEVEL 42
#define ONRSPQRYPURCHASELIMITAMT 43
#define ONRSPQRYPOSITIONLIMITVOL 44
#define ONRSPQRYHISTORYORDER 45
#define ONRSPQRYHISTORYTRADE 46
#define ONRSPQRYHISTORYASSIGNMENT 47
#define ONRSPQRYDELIVDETAIL 48
#define ONRSPAUTOEXECORDERACTION 49
#define ONRSPCOMBACTIONINSERT 50
#define ONRSPQRYINVESTORCOMBINEPOSITION 51
#define ONRSPQRYCOMBACTIONVOLUME 52
#define ONRSPFUNDOUTCREDITAPPLY 53
#define ONRSPQRYFUNDOUTCREDIT 54
#define ONRSPQRYFUNDOUTCREDITAPPLY 55
#define ONRSPERROR 56
#define ONRTNORDER 57
#define ONRTNTRADE 58
#define ONRTNEXECORDER 59
#define ONRTNLOCK 60
#define ONRTNINSTRUMENTSTATUS 61
#define ONRTNTRADINGNOTICE 62
#define ONRTNCOMBACTION 63

///-------------------------------------------------------------------------------------
///APIÖеIJ¿·Ö×é¼þ
///-------------------------------------------------------------------------------------

//GILÈ«¾ÖËø¼ò»¯»ñÈ¡Óã¬
//ÓÃÓÚ°ïÖúC++Ï̻߳ñµÃGILËø£¬´Ó¶ø·ÀÖ¹python±ÀÀ£
class PyLock
{
private:
	PyGILState_STATE gil_state;

public:
	//ÔÚij¸öº¯Êý·½·¨Öд´½¨¸Ã¶ÔÏóʱ£¬»ñµÃGILËø
	PyLock()
	{
		gil_state = PyGILState_Ensure();
	}

	//ÔÚij¸öº¯ÊýÍê³ÉºóÏú»Ù¸Ã¶ÔÏóʱ£¬½â·ÅGILËø
	~PyLock()
	{
		PyGILState_Release(gil_state);
	}
};

//ÈÎÎñ½á¹¹Ìå
struct Task
{
	int task_name;		//»Øµ÷º¯ÊýÃû³Æ¶ÔÓ¦µÄ³£Á¿
	any task_data;		//Êý¾Ý½á¹¹Ìå
	any task_error;		//´íÎó½á¹¹Ìå
	int task_id;		//ÇëÇóid
	bool task_last;		//ÊÇ·ñΪ×îºó·µ»Ø
};

///Ḭ̈߳²È«µÄ¶ÓÁÐ
template<typename Data>

class ConcurrentQueue
{
private:
	queue<Data> the_queue;								//±ê×¼¿â¶ÓÁÐ
	mutable mutex the_mutex;							//boost»¥³âËø
	condition_variable the_condition_variable;			//boostÌõ¼þ±äÁ¿

public:

	//´æÈëеÄÈÎÎñ
	void push(Data const& data)
	{
		mutex::scoped_lock lock(the_mutex);				//»ñÈ¡»¥³âËø
		the_queue.push(data);							//Ïò¶ÓÁÐÖдæÈëÊý¾Ý
		lock.unlock();									//ÊÍ·ÅËø
		the_condition_variable.notify_one();			//֪ͨÕýÔÚ×èÈûµÈ´ýµÄÏß³Ì
	}

	//¼ì²é¶ÓÁÐÊÇ·ñΪ¿Õ
	bool empty() const
	{
		mutex::scoped_lock lock(the_mutex);
		return the_queue.empty();
	}

	//È¡³ö
	Data wait_and_pop()
	{
		mutex::scoped_lock lock(the_mutex);

		while (the_queue.empty())						//µ±¶ÓÁÐΪ¿Õʱ
		{
			the_condition_variable.wait(lock);			//µÈ´ýÌõ¼þ±äÁ¿Í¨Öª
		}

		Data popped_value = the_queue.front();			//»ñÈ¡¶ÓÁÐÖеÄ×îºóÒ»¸öÈÎÎñ
		the_queue.pop();								//ɾ³ý¸ÃÈÎÎñ
		return popped_value;							//·µ»Ø¸ÃÈÎÎñ
	}

};

//´Ó×ÖµäÖлñȡij¸ö½¨Öµ¶ÔÓ¦µÄÕûÊý£¬²¢¸³Öµµ½ÇëÇó½á¹¹Ìå¶ÔÏóµÄÖµÉÏ
void getInt(dict d, string key, int* value);

//´Ó×ÖµäÖлñȡij¸ö½¨Öµ¶ÔÓ¦µÄ¸¡µãÊý£¬²¢¸³Öµµ½ÇëÇó½á¹¹Ìå¶ÔÏóµÄÖµÉÏ
void getDouble(dict d, string key, double* value);

//´Ó×ÖµäÖлñȡij¸ö½¨Öµ¶ÔÓ¦µÄ×Ö·û´®£¬²¢¸³Öµµ½ÇëÇó½á¹¹Ìå¶ÔÏóµÄÖµÉÏ
void getChar(dict d, string key, char* value);

///-------------------------------------------------------------------------------------
///C++ SPIµÄ»Øµ÷º¯Êý·½·¨ÊµÏÖ
///-------------------------------------------------------------------------------------

//APIµÄ¼Ì³ÐʵÏÖ
class TdApi : public CKSOTPTraderSpi
{
private:
	CKSOTPTraderApi* api;			//API¶ÔÏó
	thread *task_thread;				//¹¤×÷Ïß³ÌÖ¸Õ루ÏòpythonÖÐÍÆËÍÊý¾Ý£©
	ConcurrentQueue<Task> task_queue;	//ÈÎÎñ¶ÓÁÐ

public:
	TdApi()
	{
		function0<void> f = boost::bind(&TdApi::processTask, this);
		thread t(f);
		this->task_thread = &t;
	};

	~TdApi()
	{
	};

	//-------------------------------------------------------------------------------------
	//API»Øµ÷º¯Êý
	//-------------------------------------------------------------------------------------

	///µ±¿Í»§¶ËÓë½»Ò׺ǫ́½¨Á¢ÆðͨÐÅÁ¬½Óʱ£¨»¹Î´µÇ¼ǰ£©£¬¸Ã·½·¨±»µ÷ÓÃ.
	virtual void OnFrontConnected();

	///µ±¿Í»§¶ËÓë½»Ò׺ǫ́ͨÐÅÁ¬½Ó¶Ï¿ªÊ±£¬¸Ã·½·¨±»µ÷ÓÃ.
	///@param nReason ´íÎóÔÒò
	///        0x1001 ÍøÂç¶Áʧ°Ü
	///        0x1002 ÍøÂçдʧ°Ü
	///        0x2001 ½ÓÊÕÐÄÌø³¬Ê±
	///        0x2002 ·¢ËÍÐÄÌøʧ°Ü
	///        0x2003 ÊÕµ½´íÎó±¨ÎÄ
	///        0x2004 ·þÎñÆ÷Ö÷¶¯¶Ï¿ª
	virtual void OnFrontDisconnected(int nReason);

	///µÇ¼ÇëÇóÏìÓ¦
	virtual void OnRspUserLogin(CKSOTPRspUserLoginField *pRspUserLogin, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///µÇ³öÇëÇóÏìÓ¦
	virtual void OnRspUserLogout(CKSOTPUserLogoutField *pUserLogout, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///Óû§¿ÚÁî¸üÐÂÇëÇóÏìÓ¦
	virtual void OnRspUserPasswordUpdate(CKSOTPUserPasswordUpdateField *pUserPasswordUpdate, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///×ʽðÕË»§¿ÚÁî¸üÐÂÇëÇóÏìÓ¦
	virtual void OnRspTradingAccountPasswordUpdate(CKSOTPTradingAccountPasswordUpdateField *pTradingAccountPasswordUpdate, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///±¨µ¥Â¼ÈëÇëÇóÏìÓ¦
	virtual void OnRspOrderInsert(CKSOTPInputOrderField *pInputOrder, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///±¨µ¥²Ù×÷ÇëÇóÏìÓ¦
	virtual void OnRspOrderAction(CKSOTPInputOrderActionField *pInputOrderAction, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯ±¨µ¥ÏìÓ¦
	virtual void OnRspQryOrder(CKSOTPOrderField *pOrder, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯ³É½»ÏìÓ¦
	virtual void OnRspQryTrade(CKSOTPTradeField *pTrade, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯͶ×ÊÕß³Ö²ÖÏìÓ¦
	virtual void OnRspQryInvestorPosition(CKSOTPInvestorPositionField *pInvestorPosition, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯ×ʽðÕË»§ÏìÓ¦
	virtual void OnRspQryTradingAccount(CKSOTPTradingAccountField *pTradingAccount, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯͶ×ÊÕßÏìÓ¦
	virtual void OnRspQryInvestor(CKSOTPInvestorField *pInvestor, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯºÏÔ¼Õ˺ÅÏìÓ¦
	virtual void OnRspQryTradingCode(CKSOTPTradingCodeField *pTradingCode, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯ½»Ò×ËùÏìÓ¦
	virtual void OnRspQryExchange(CKSOTPExchangeField *pExchange, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯºÏÔ¼ÏìÓ¦
	virtual void OnRspQryInstrument(CKSOTPInstrumentField *pInstrument, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯͶ×ÊÕß³Ö²ÖÃ÷ϸÏìÓ¦
	virtual void OnRspQryInvestorPositionDetail(CKSOTPInvestorPositionDetailField *pInvestorPositionDetail, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯ½»Ò×֪ͨÏìÓ¦
	virtual void OnRspQryTradingNotice(CKSOTPTradingNoticeField *pTradingNotice, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///Ö´ÐÐÐû¸æ¼ÈëÇëÇóÏìÓ¦
	virtual void OnRspExecOrderInsert(CKSOTPInputExecOrderField *pInputExecOrder, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///Ëø¶¨Ó¦´ð
	virtual void OnRspLockInsert(CKSOTPInputLockField *pInputLock, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///Ö´ÐÐÐû¸æ²Ù×÷ÇëÇóÏìÓ¦
	virtual void OnRspExecOrderAction(CKSOTPInputExecOrderActionField *pInputExecOrderAction, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯִÐÐÐû¸æÏìÓ¦
	virtual void OnRspQryExecOrder(CKSOTPExecOrderField *pExecOrder, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///²éѯÐû¸æÊýÁ¿ÇëÇóÏìÓ¦
	virtual void OnRspQryExecOrderVolume(CKSOTPExecOrderVolumeField *pExecOrderVolume, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯËø¶¨Ó¦´ð
	virtual void OnRspQryLock(CKSOTPLockField *pLock, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯËø¶¨Ö¤È¯²ÖλӦ´ð
	virtual void OnRspQryLockPosition(CKSOTPLockPositionField *pLockPosition, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯ±êµÄȯÐÅÏ¢ÏìÓ¦
	virtual void OnRspQryUnderlyingStockInfo(CKSOTPUnderlyingStockInfoField *pUnderlyingStockInfo, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///²éѯ¸ö¹ÉÆÚȨÊÖÐø·ÑÂÊÇëÇóÏìÓ¦
	virtual void OnRspQryOTPInsCommRate(CKSOTPOTPInsCommRateField *pOTPInsCommRate, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///²éѯ¸ö¹ÉÆÚȨºÏÔ¼±£Ö¤½ðÂÊÇëÇóÏìÓ¦
	virtual void OnRspQryInstrumentMarginRate(CKSOTPInstrumentMarginRateField *pInstrumentMarginRate, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///²éѯ¸ö¹ÉÐÐȨָÅÉÐÅÏ¢ÇëÇóÏìÓ¦
	virtual void OnRspQryOTPAssignment(CKSOTPOTPAssignmentField *pOTPAssignment, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯÐÐÇéÏìÓ¦
	virtual void OnRspQryDepthMarketData(CKSOTPDepthMarketDataField *pDepthMarketData, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///·¢ÆðÒøÐÐ×ʽðת֤ȯӦ´ð
	virtual void OnRspFromBankToStockByStock(CKSOTPReqTransferField *pReqTransfer, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///֤ȯ·¢ÆðÒøÐÐ×ʽðת֤ȯ֪ͨ
	virtual void OnRtnFromBankToStockByStock(CKSOTPRspTransferField *pRspTransfer);

	///֤ȯ·¢Æð֤ȯ×ʽðתÒøÐÐÓ¦´ð
	virtual void OnRspFromStockToBankByStock(CKSOTPReqTransferField *pReqTransfer, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///֤ȯ·¢Æð֤ȯ×ʽðתÒøÐÐ֪ͨ
	virtual void OnRtnFromStockToBankByStock(CKSOTPRspTransferField *pRspTransfer);

	///֤ȯ·¢Æð²éѯÒøÐÐÓà¶î֪ͨ
	virtual void OnRtnQueryBankBalanceByStock(CKSOTPNotifyQueryAccountField *pNotifyQueryAccount);

	///ÇëÇó²éѯǩԼÒøÐÐÏìÓ¦
	virtual void OnRspQryContractBank(CKSOTPContractBankField *pContractBank, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///֤ȯ·¢Æð²éѯÒøÐÐÓà¶îÓ¦´ð
	virtual void OnRspQueryBankAccountMoneyByStock(CKSOTPReqQueryAccountField *pReqQueryAccount, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯתÕÊÁ÷Ë®ÏìÓ¦
	virtual void OnRspQryTransferSerial(CKSOTPTransferSerialField *pTransferSerial, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯ½áËãÐÅϢȷÈÏÏìÓ¦
	virtual void OnRspQrySettlementInfoConfirm(CKSOTPSettlementInfoConfirmField *pSettlementInfoConfirm, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///Ͷ×ÊÕß½áËã½á¹ûÈ·ÈÏÏìÓ¦
	virtual void OnRspSettlementInfoConfirm(CKSOTPSettlementInfoConfirmField *pSettlementInfoConfirm, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯͶ×ÊÕß½áËã½á¹ûÏìÓ¦
	virtual void OnRspQrySettlementInfo(CKSOTPSettlementInfoField *pSettlementInfo, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///²éѯ¿Í»§½»Ò×¼¶±ðÏìÓ¦
	virtual void OnRspQryInvestorTradeLevel(CKSOTPInvestorTradeLevelField *pInvestorTradeLevel, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///²éѯ¸ö¹ÉÏÞ¹º¶î¶ÈÏìÓ¦
	virtual void OnRspQryPurchaseLimitAmt(CKSOTPPurchaseLimitAmtField *pPurchaseLimitAmt, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///²éѯ¸ö¹ÉÏÞ²Ö¶î¶ÈÏìÓ¦
	virtual void OnRspQryPositionLimitVol(CKSOTPPositionLimitVolField *pPositionLimitVol, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯÀúÊ·±¨µ¥ÏìÓ¦
	virtual void OnRspQryHistoryOrder(CKSOTPHistoryOrderField *pHistoryOrder, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯÀúÊ·³É½»ÏìÓ¦
	virtual void OnRspQryHistoryTrade(CKSOTPHistoryTradeField *pHistoryTrade, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯÀúÊ·ÐÐȨָÅÉÃ÷ϸÏìÓ¦
	virtual void OnRspQryHistoryAssignment(CKSOTPHistoryAssignmentField *pHistoryAssignment, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÇëÇó²éѯÐÐȨ½»¸îÃ÷ϸÏìÓ¦
	virtual void OnRspQryDelivDetail(CKSOTPDelivDetailField *pDelivDetail, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///×Ô¶¯ÐÐȨִÐвÙ×÷ÏìÓ¦
	virtual void OnRspAutoExecOrderAction(CKSOTPAutoExecOrderActionField *pAutoExecOrderAction, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///ÉêÇë×éºÏ¼ÈëÇëÇóÏìÓ¦
	virtual void OnRspCombActionInsert(CKSOTPInputCombActionField *pInputCombAction, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///²éѯ¸ö¹É×éºÏ³Ö²ÖÃ÷ϸӦ´ð
	virtual void OnRspQryInvestorCombinePosition(CKSOTPInvestorPositionCombineDetailField *pInvestorPositionCombineDetail, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///¸ö¹É¿É×éºÏ¿É²ð·ÖÊÖÊýÇëÇóÏìÓ¦
	virtual void OnRspQryCombActionVolume(CKSOTPCombActionVolumeField *pCombActionVolume, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///¿Í»§Ã¿ÈÕ³ö½ð¶î¶ÈÉêÇëÏìÓ¦
	virtual void OnRspFundOutCreditApply(CKSOTPInputFundOutCreditApplyField *pFundOutCreditApply, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///¿Í»§Ã¿ÈÕ³ö½ð¶î¶È²éѯÏìÓ¦
	virtual void OnRspQryFundOutCredit(CKSOTPRspQryFundOutCreditField *pRspQryFundOutCredit, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///¿Í»§Ã¿ÈÕ³ö½ð¶î¶ÈÉêÇë²éѯÏìÓ¦
	virtual void OnRspQryFundOutCreditApply(CKSOTPRspQryFundOutCreditApplyField *pRspQryFundOutCreditApply, CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///´íÎóÓ¦´ð
	virtual void OnRspError(CKSOTPRspInfoField *pRspInfo, int nRequestID, bool bIsLast);

	///±¨µ¥Í¨Öª
	virtual void OnRtnOrder(CKSOTPOrderField *pOrder);

	///³É½»Í¨Öª
	virtual void OnRtnTrade(CKSOTPTradeField *pTrade);

	///Ö´ÐÐÐû¸æ֪ͨ
	virtual void OnRtnExecOrder(CKSOTPExecOrderField *pExecOrder);

	///Ëø¶¨Í¨Öª
	virtual void OnRtnLock(CKSOTPLockField *pLock);

	///ºÏÔ¼½»Ò×״̬֪ͨ
	virtual void OnRtnInstrumentStatus(CKSOTPInstrumentStatusField *pInstrumentStatus);

	///½»Ò×֪ͨ
	virtual void OnRtnTradingNotice(CKSOTPTradingNoticeInfoField *pTradingNoticeInfo);

	///¸ö¹É×éºÏ²ð·ÖίÍÐ֪ͨ
	virtual void OnRtnCombAction(CKSOTPCombActionField *pCombAction);

	//-------------------------------------------------------------------------------------
	//task£ºÈÎÎñ
	//-------------------------------------------------------------------------------------

	void processTask();

	void processFrontConnected(Task task);

	void processFrontDisconnected(Task task);

	void processRspUserLogin(Task task);

	void processRspUserLogout(Task task);

	void processRspUserPasswordUpdate(Task task);

	void processRspTradingAccountPasswordUpdate(Task task);

	void processRspOrderInsert(Task task);

	void processRspOrderAction(Task task);

	void processRspQryOrder(Task task);

	void processRspQryTrade(Task task);

	void processRspQryInvestorPosition(Task task);

	void processRspQryTradingAccount(Task task);

	void processRspQryInvestor(Task task);

	void processRspQryTradingCode(Task task);

	void processRspQryExchange(Task task);

	void processRspQryInstrument(Task task);

	void processRspQryInvestorPositionDetail(Task task);

	void processRspQryTradingNotice(Task task);

	void processRspExecOrderInsert(Task task);

	void processRspLockInsert(Task task);

	void processRspExecOrderAction(Task task);

	void processRspQryExecOrder(Task task);

	void processRspQryExecOrderVolume(Task task);

	void processRspQryLock(Task task);

	void processRspQryLockPosition(Task task);

	void processRspQryUnderlyingStockInfo(Task task);

	void processRspQryOTPInsCommRate(Task task);

	void processRspQryInstrumentMarginRate(Task task);

	void processRspQryOTPAssignment(Task task);

	void processRspQryDepthMarketData(Task task);

	void processRspFromBankToStockByStock(Task task);

	void processRtnFromBankToStockByStock(Task task);

	void processRspFromStockToBankByStock(Task task);

	void processRtnFromStockToBankByStock(Task task);

	void processRtnQueryBankBalanceByStock(Task task);

	void processRspQryContractBank(Task task);

	void processRspQueryBankAccountMoneyByStock(Task task);

	void processRspQryTransferSerial(Task task);

	void processRspQrySettlementInfoConfirm(Task task);

	void processRspSettlementInfoConfirm(Task task);

	void processRspQrySettlementInfo(Task task);

	void processRspQryInvestorTradeLevel(Task task);

	void processRspQryPurchaseLimitAmt(Task task);

	void processRspQryPositionLimitVol(Task task);

	void processRspQryHistoryOrder(Task task);

	void processRspQryHistoryTrade(Task task);

	void processRspQryHistoryAssignment(Task task);

	void processRspQryDelivDetail(Task task);

	void processRspAutoExecOrderAction(Task task);

	void processRspCombActionInsert(Task task);

	void processRspQryInvestorCombinePosition(Task task);

	void processRspQryCombActionVolume(Task task);

	void processRspFundOutCreditApply(Task task);

	void processRspQryFundOutCredit(Task task);

	void processRspQryFundOutCreditApply(Task task);

	void processRspError(Task task);

	void processRtnOrder(Task task);

	void processRtnTrade(Task task);

	void processRtnExecOrder(Task task);

	void processRtnLock(Task task);

	void processRtnInstrumentStatus(Task task);

	void processRtnTradingNotice(Task task);

	void processRtnCombAction(Task task);

	//-------------------------------------------------------------------------------------
	//data£º»Øµ÷º¯ÊýµÄÊý¾Ý×Öµä
	//error£º»Øµ÷º¯ÊýµÄ´íÎó×Öµä
	//id£ºÇëÇóid
	//last£ºÊÇ·ñΪ×îºó·µ»Ø
	//i£ºÕûÊý
	//-------------------------------------------------------------------------------------

	virtual void onFrontConnected(){};

	virtual void onFrontDisconnected(int i){};

	virtual void onRspError(dict error, int id, bool last) {};

	virtual void onRspUserLogin(dict data, dict error, int id, bool last) {};

	virtual void onRspUserLogout(dict data, dict error, int id, bool last) {};

	virtual void onRspUserPasswordUpdate(dict data, dict error, int id, bool last) {};

	virtual void onRspTradingAccountPasswordUpdate(dict data, dict error, int id, bool last) {};

	virtual void onRspOrderInsert(dict data, dict error, int id, bool last) {};

	virtual void onRspOrderAction(dict data, dict error, int id, bool last) {};

	virtual void onRspQryOrder(dict data, dict error, int id, bool last) {};

	virtual void onRspQryTrade(dict data, dict error, int id, bool last) {};

	virtual void onRspQryInvestorPosition(dict data, dict error, int id, bool last) {};

	virtual void onRspQryTradingAccount(dict data, dict error, int id, bool last) {};

	virtual void onRspQryInvestor(dict data, dict error, int id, bool last) {};

	virtual void onRspQryTradingCode(dict data, dict error, int id, bool last) {};

	virtual void onRspQryExchange(dict data, dict error, int id, bool last) {};

	virtual void onRspQryInstrument(dict data, dict error, int id, bool last) {};

	virtual void onRspQryInvestorPositionDetail(dict data, dict error, int id, bool last) {};

	virtual void onRspQryTradingNotice(dict data, dict error, int id, bool last) {};

	virtual void onRspExecOrderInsert(dict data, dict error, int id, bool last) {};

	virtual void onRspLockInsert(dict data, dict error, int id, bool last) {};

	virtual void onRspExecOrderAction(dict data, dict error, int id, bool last) {};

	virtual void onRspQryExecOrder(dict data, dict error, int id, bool last) {};

	virtual void onRspQryExecOrderVolume(dict data, dict error, int id, bool last) {};

	virtual void onRspQryLock(dict data, dict error, int id, bool last) {};

	virtual void onRspQryLockPosition(dict data, dict error, int id, bool last) {};

	virtual void onRspQryUnderlyingStockInfo(dict data, dict error, int id, bool last) {};

	virtual void onRspQryOTPInsCommRate(dict data, dict error, int id, bool last) {};

	virtual void onRspQryInstrumentMarginRate(dict data, dict error, int id, bool last) {};

	virtual void onRspQryOTPAssignment(dict data, dict error, int id, bool last) {};

	virtual void onRspQryDepthMarketData(dict data, dict error, int id, bool last) {};

	virtual void onRspFromBankToStockByStock(dict data, dict error, int id, bool last) {};

	virtual void onRtnFromBankToStockByStock(dict data) {};

	virtual void onRspFromStockToBankByStock(dict data, dict error, int id, bool last) {};

	virtual void onRtnFromStockToBankByStock(dict data) {};

	virtual void onRtnQueryBankBalanceByStock(dict data) {};

	virtual void onRspQryContractBank(dict data, dict error, int id, bool last) {};

	virtual void onRspQueryBankAccountMoneyByStock(dict data, dict error, int id, bool last) {};

	virtual void onRspQryTransferSerial(dict data, dict error, int id, bool last) {};

	virtual void onRspQrySettlementInfoConfirm(dict data, dict error, int id, bool last) {};

	virtual void onRspSettlementInfoConfirm(dict data, dict error, int id, bool last) {};

	virtual void onRspQrySettlementInfo(dict data, dict error, int id, bool last) {};

	virtual void onRspQryInvestorTradeLevel(dict data, dict error, int id, bool last) {};

	virtual void onRspQryPurchaseLimitAmt(dict data, dict error, int id, bool last) {};

	virtual void onRspQryPositionLimitVol(dict data, dict error, int id, bool last) {};

	virtual void onRspQryHistoryOrder(dict data, dict error, int id, bool last) {};

	virtual void onRspQryHistoryTrade(dict data, dict error, int id, bool last) {};

	virtual void onRspQryHistoryAssignment(dict data, dict error, int id, bool last) {};

	virtual void onRspQryDelivDetail(dict data, dict error, int id, bool last) {};

	virtual void onRspAutoExecOrderAction(dict data, dict error, int id, bool last) {};

	virtual void onRspCombActionInsert(dict data, dict error, int id, bool last) {};

	virtual void onRspQryInvestorCombinePosition(dict data, dict error, int id, bool last) {};

	virtual void onRspQryCombActionVolume(dict data, dict error, int id, bool last) {};

	virtual void onRspFundOutCreditApply(dict data, dict error, int id, bool last) {};

	virtual void onRspQryFundOutCredit(dict data, dict error, int id, bool last) {};

	virtual void onRspQryFundOutCreditApply(dict data, dict error, int id, bool last) {};

	virtual void onRtnOrder(dict data) {};

	virtual void onRtnTrade(dict data) {};

	virtual void onRtnExecOrder(dict data) {};

	virtual void onRtnLock(dict data) {};

	virtual void onRtnInstrumentStatus(dict data) {};

	virtual void onRtnTradingNotice(dict data) {};

	virtual void onRtnCombAction(dict data) {};

	//-------------------------------------------------------------------------------------
	//req:Ö÷¶¯º¯ÊýµÄÇëÇó×Öµä
	//-------------------------------------------------------------------------------------

	void createOTPTraderApi(string pszFlowPath = "");

	void release();

	void init();

	int exit();

	string getTradingDay();

	void registerFront(string pszFrontAddress);

	void subscribePrivateTopic(int nType);

	void subscribePublicTopic(int nType);

	int reqUserLogin(dict req, int nRequestID);

	int reqUserLogout(dict req, int nRequestID);

	int reqUserPasswordUpdate(dict req, int nRequestID);

	int reqTradingAccountPasswordUpdate(dict req, int nRequestID);

	int reqOrderInsert(dict req, int nRequestID);

	int reqOrderAction(dict req, int nRequestID);

	int reqQryOrder(dict req, int nRequestID);

	int reqQryTrade(dict req, int nRequestID);

	int reqQryInvestorPosition(dict req, int nRequestID);

	int reqQryTradingAccount(dict req, int nRequestID);

	int reqQryInvestor(dict req, int nRequestID);

	int reqQryTradingCode(dict req, int nRequestID);

	int reqQryExchange(dict req, int nRequestID);

	int reqQryInstrument(dict req, int nRequestID);

	int reqQryInvestorPositionDetail(dict req, int nRequestID);

	int reqQryTradingNotice(dict req, int nRequestID);

	int reqExecOrderInsert(dict req, int nRequestID);

	int reqExecOrderAction(dict req, int nRequestID);

	int reqLockInsert(dict req, int nRequestID);

	int reqQryExecOrder(dict req, int nRequestID);

	int reqQryExecOrderVolume(dict req, int nRequestID);

	int reqQryLock(dict req, int nRequestID);

	int reqQryLockPosition(dict req, int nRequestID);

	int reqQryUnderlyingStockInfo(dict req, int nRequestID);

	int reqQryOTPInsCommRate(dict req, int nRequestID);

	int reqQryInstrumentMarginRate(dict req, int nRequestID);

	int reqQryOTPAssignment(dict req, int nRequestID);

	int reqQryDepthMarketData(dict req, int nRequestID);

	int reqFromBankToStockByStock(dict req, int nRequestID);

	int reqFromStockToBankByStock(dict req, int nRequestID);

	int reqQryContractBank(dict req, int nRequestID);

	int reqQueryBankAccountMoneyByStock(dict req, int nRequestID);

	int reqQryTransferSerial(dict req, int nRequestID);

	int reqQrySettlementInfoConfirm(dict req, int nRequestID);

	int reqSettlementInfoConfirm(dict req, int nRequestID);

	int reqQrySettlementInfo(dict req, int nRequestID);

	int reqQryInvestorTradeLevel(dict req, int nRequestID);

	int reqQryPurchaseLimitAmt(dict req, int nRequestID);

	int reqQryPositionLimitVol(dict req, int nRequestID);

	int reqQryHistoryOrder(dict req, int nRequestID);

	int reqQryHistoryTrade(dict req, int nRequestID);

	int reqQryHistoryAssignment(dict req, int nRequestID);

	int reqQryDelivDetail(dict req, int nRequestID);

	int reqAutoExecOrderAction(dict req, int nRequestID);

	int reqCombActionInsert(dict req, int nRequestID);

	int reqQryInvestorCombinePosition(dict req, int nRequestID);

	int reqQryCombActionVolume(dict req, int nRequestID);

	int reqFundOutCreditApply(dict req, int nRequestID);

	int reqQryFundOutCredit(dict req, int nRequestID);

	int reqQryFundOutCreditApply(dict req, int nRequestID);
};


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<TITLE
>Index Uniqueness Checks</TITLE
><META
NAME="GENERATOR"
CONTENT="Modular DocBook HTML Stylesheet Version 1.79"><LINK
REV="MADE"
HREF="mailto:pgsql-docs@postgresql.org"><LINK
REL="HOME"
TITLE="PostgreSQL 9.0.5 Documentation"
HREF="index.html"><LINK
REL="UP"
TITLE="Index Access Method Interface Definition"
HREF="indexam.html"><LINK
REL="PREVIOUS"
TITLE="Index Locking Considerations"
HREF="index-locking.html"><LINK
REL="NEXT"
TITLE="Index Cost Estimation Functions"
HREF="index-cost-estimation.html"><LINK
REL="STYLESHEET"
TYPE="text/css"
HREF="stylesheet.css"><META
HTTP-EQUIV="Content-Type"
CONTENT="text/html; charset=ISO-8859-1"><META
NAME="creation"
CONTENT="2011-09-22T22:21:03">

PostgreSQL 9.0.5 Documentation

Prev	Fast Backward	Chapter 51. Index Access Method Interface Definition	Fast Forward	Next

51.5. Index Uniqueness Checks

   PostgreSQL enforces SQL uniqueness constraints
   using unique indexes, which are indexes that disallow
   multiple entries with identical keys.  An access method that supports this
   feature sets <TT
CLASS="STRUCTNAME"
>pg_am</TT
>.<TT
CLASS="STRUCTFIELD"
>amcanunique</TT
> true.
   (At present, only b-tree supports it.)

   Because of MVCC, it is always necessary to allow duplicate entries to
   exist physically in an index: the entries might refer to successive
   versions of a single logical row.  The behavior we actually want to
   enforce is that no MVCC snapshot could include two rows with equal
   index keys.  This breaks down into the following cases that must be
   checked when inserting a new row into a unique index:

       If a conflicting valid row has been deleted by the current transaction,
       it's okay.  (In particular, since an UPDATE always deletes the old row
       version before inserting the new version, this will allow an UPDATE on
       a row without changing the key.)

       If a conflicting row has been inserted by an as-yet-uncommitted
       transaction, the would-be inserter must wait to see if that transaction
       commits.  If it rolls back then there is no conflict.  If it commits
       without deleting the conflicting row again, there is a uniqueness
       violation.  (In practice we just wait for the other transaction to
       end and then redo the visibility check in toto.)

       Similarly, if a conflicting valid row has been deleted by an
       as-yet-uncommitted transaction, the would-be inserter must wait
       for that transaction to commit or abort, and then repeat the test.

   Furthermore, immediately before reporting a uniqueness violation
   according to the above rules, the access method must recheck the
   liveness of the row being inserted.  If it is committed dead then
   no violation should be reported.  (This case cannot occur during the
   ordinary scenario of inserting a row that's just been created by
   the current transaction.  It can happen during
   <TT
CLASS="COMMAND"
>CREATE UNIQUE INDEX CONCURRENTLY</TT
>, however.)

   We require the index access method to apply these tests itself, which
   means that it must reach into the heap to check the commit status of
   any row that is shown to have a duplicate key according to the index
   contents.  This is without a doubt ugly and non-modular, but it saves
   redundant work: if we did a separate probe then the index lookup for
   a conflicting row would be essentially repeated while finding the place to
   insert the new row's index entry.  What's more, there is no obvious way
   to avoid race conditions unless the conflict check is an integral part
   of insertion of the new index entry.

   If the unique constraint is deferrable, there is additional complexity:
   we need to be able to insert an index entry for a new row, but defer any
   uniqueness-violation error until end of statement or even later.  To
   avoid unnecessary repeat searches of the index, the index access method
   should do a preliminary uniqueness check during the initial insertion.
   If this shows that there is definitely no conflicting live tuple, we
   are done.  Otherwise, we schedule a recheck to occur when it is time to
   enforce the constraint.  If, at the time of the recheck, both the inserted
   tuple and some other tuple with the same key are live, then the error
   must be reported.  (Note that for this purpose, "live" actually
   means "any tuple in the index entry's HOT chain is live".)
   To implement this, the aminsert function is passed a
   <TT
CLASS="LITERAL"
>checkUnique</TT
> parameter having one of the following values:

       <TT
CLASS="LITERAL"
>UNIQUE_CHECK_NO</TT
> indicates that no uniqueness checking
       should be done (this is not a unique index).

       <TT
CLASS="LITERAL"
>UNIQUE_CHECK_YES</TT
> indicates that this is a non-deferrable
       unique index, and the uniqueness check must be done immediately, as
       described above.

       <TT
CLASS="LITERAL"
>UNIQUE_CHECK_PARTIAL</TT
> indicates that the unique
       constraint is deferrable. PostgreSQL
       will use this mode to insert each row's index entry.  The access
       method must allow duplicate entries into the index, and report any
       potential duplicates by returning FALSE from aminsert.
       For each row for which FALSE is returned, a deferred recheck will
       be scheduled.

       The access method must identify any rows which might violate the
       unique constraint, but it is not an error for it to report false
       positives. This allows the check to be done without waiting for other
       transactions to finish; conflicts reported here are not treated as
       errors and will be rechecked later, by which time they may no longer
       be conflicts.

       <TT
CLASS="LITERAL"
>UNIQUE_CHECK_EXISTING</TT
> indicates that this is a deferred
       recheck of a row that was reported as a potential uniqueness violation.
       Although this is implemented by calling aminsert, the
       access method must not insert a new index entry in this
       case.  The index entry is already present.  Rather, the access method
       must check to see if there is another live index entry.  If so, and
       if the target row is also still live, report error.

       It is recommended that in a <TT
CLASS="LITERAL"
>UNIQUE_CHECK_EXISTING</TT
> call,
       the access method further verify that the target row actually does
       have an existing entry in the index, and report error if not.  This
       is a good idea because the index tuple values passed to
       aminsert will have been recomputed.  If the index
       definition involves functions that are not really immutable, we
       might be checking the wrong area of the index.  Checking that the
       target row is found in the recheck verifies that we are scanning
       for the same tuple values as were used in the original insertion.

Prev	Home	Next

Index Locking Considerations	Up	Index Cost Estimation Functions


text:
class HealthchecksController < ApplicationController
  def show
    error = nil
    begin
      ActiveRecord::Migration.check_pending!
    rescue ActiveRecord::PendingMigrationError => ex
      error = ex.message
    end
    if error
      render plain: "error: #{error}"
    else
      render plain: "success"
    end
    return true
  end
end


text:
title: "Content Management System"
members: "Trey (Scrum Master), Jacob and Paul"
layout: group
link: TBD
description: "Content Content Management System team is responsible for the final technical architecture that users will interact with, via the CMS.  They'll also work closely on items that require more advanced database or dynamic functionality, including JavaScript.  This team will ultimately define the content structure and types in the CMS, building out HTML templates, CSS (SASS) and JavaScript that has been technically tested and takes performance and accessibility into account."
semester: spring-2018
date: 2016-7-11 12:00:00
number: 3
---

**Collaboration**

* The CMS team will work closely with the content/UX team to ensure appropriate content types are developed and that those content types are intuitive for CMS users to input content.
* They'll also work closely with the visual design team, taking completed design patterns and integrating them into the final templates via HTML, CSS and JavaScript.

**Milestones**

* 3.1 - Participate in Craft CMS training and build hands-on practice website (one-time)
* 3.2 - Create and update content model document detailing proposed content types and fields for CMS (ongoing)
* 3.3 - Create and update fields within the CMS based on the content and design needs (ongoing)
* 3.4 - Work with the design team to integrate static/interactive design concepts into dynamic CMS templates (using the Twig language).  Revise and edit front-end code for consistency and best practices
* 3.5 - Utilize JavaScript and other scripting languages to create more complex interactions and tools as needed, collaborating with design team
* 3.6 - Teach UX team how to use CMS to input content
* 3.7 - Install major plugins as needed, including Search Engine Optimization, Menus and Analytics

**Floating Role: ScrumMaster**

One member of the CMS team will also be designated as ScrumMaster and take on these responsibilities, in addition to tasks that need done on the CMS.

* 4.1 - Help run and ensure Scrum meetings happen within 15 minutes and twice per week
* 4.2 - Ensure sprint goal is set and agreed upon
* 4.3 - Help ensure sprint tasks are assigned and updated weekly (in conjunction with Product Owner/Instructor)
* 4.4 - Spends time working with UX, Design and CMS teams to get updates and understand deliverables, as needed
* 4.5 - Communicates needs across teams to the class


text:
from .utils import (
    create_container_config,
    restart_container_config,
    start_container_config,
    inject_file_config,
    admin_password_config,
    create_image_config,
)


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.netbeans.org/ns/project/1">
    <type>org.netbeans.modules.web.project</type>
    <configuration>
        <data xmlns="http://www.netbeans.org/ns/web-project/3">
            <name>Planner Web Application</name>
            <minimum-ant-version>1.6.5</minimum-ant-version>
            <web-module-libraries/>
            <web-module-additional-libraries/>
            <source-roots>
                <root id="src.dir" name="Source Packages"/>
            </source-roots>
            <test-roots>
                <root id="test.src.dir" name="Test Packages"/>
            </test-roots>
        </data>
    </configuration>
</project>


text:
"""
py_vollib.black_scholes
~~~~~~~~~~~~~~~~~~~~~~~

A library for option pricing, implied volatility, and
greek calculation.  py_vollib is based on lets_be_rational,
a Python wrapper for LetsBeRational by Peter Jaeckel as
described below.

:copyright: © 2017 Gammon Capital LLC
:license: MIT, see LICENSE for more details.

About LetsBeRational:
~~~~~~~~~~~~~~~~~~~~~

The source code of LetsBeRational resides at www.jaeckel.org/LetsBeRational.7z .

::

    ========================================================================================
    Copyright © 2013-2014 Peter Jäckel.

    Permission to use, copy, modify, and distribute this software is freely granted,
    provided that this notice is preserved.

    WARRANTY DISCLAIMER
    The Software is provided "as is" without warranty of any kind, either express or implied,
    including without limitation any implied warranties of condition, uninterrupted use,
    merchantability, fitness for a particular purpose, or non-infringement.
    ========================================================================================

"""

# -----------------------------------------------------------------------------
# IMPORTS

# Standard library imports
from __future__ import division

# Related third party imports
import numpy

# Local application/library specific imports
from py_vollib.black import undiscounted_black

# -----------------------------------------------------------------------------
# FUNCTIONS

def black_scholes(flag, S, K, t, r, sigma):
    """Return the Black-Scholes option price.

    :param S: underlying asset price
    :type S: float
    :param K: strike price
    :type K: float
    :param sigma: annualized standard deviation, or volatility
    :type sigma: float
    :param t: time to expiration in years
    :type t: float
    :param r: risk-free interest rate
    :type r: float
    :param flag: 'c' or 'p' for call or put.
    :type flag: str

    >>> c = black_scholes('c',100,90,.5,.01,.2)
    >>> abs(c - 12.111581435) < .000001
    True

    >>> p = black_scholes('p',100,90,.5,.01,.2)
    >>> abs(p - 1.66270456231) < .000001
    True
    """

    deflater = numpy.exp(-r * t)
    F = S / deflater
    return undiscounted_black(F, K, sigma, t, flag) * deflater

if __name__ == "__main__":
    from py_vollib.helpers.doctest_helper import run_doctest
    run_doctest()


text:
module CMIS
  class PropertyDefinition
    def initialize(hash = {})
      @hash = hash.stringify_keys
      @hash.each_key do |key|
        self.class.class_eval "def #{key.as_ruby_property};@hash['#{key}'];end"
        self.class.class_eval "def #{key.as_ruby_property}=(value);@hash['#{key}']=value;end"
      end
    end

    def readonly?
      updatability == 'readonly'
    end

    def oncreate?
      updatability == 'oncreate'
    end

    def readwrite?
      updatability == 'readwrite'
    end

    def to_hash
      @hash
    end
  end
end


text:
<!DOCTYPE html>
<html>
<body>
<h1> Crittografia </h1>
Questo pannello è per imparare la crittografia.
</body>
</html>


text:
package gps;

import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;

/**
 * A class produce current or custom Location.
 * Adapted from https://github.com/baoliangwang/CurrentLocation
 * @author xuping
 */
public class LocationGenerator{
	private LocationManager lm = null;
	private Location currentLocation=null;
	private LocationListener locationListener=null;
	/**
	 * Construct a Location_Generator with a LocationManager and create a new Location Listener.
	 * @param lm a LocationManager
	 */
	public LocationGenerator(LocationManager lm){
		this.lm=lm;
		this.locationListener=new LocationListener(){

			@Override
			public void onLocationChanged(Location location){
				if(location!=null){
					System.out.println("Location Changed");
				}
				else{
					System.out.println("Error: can not get the location.");
				}
			}

			@Override
			public void onProviderDisabled(String provider){}

			@Override
			public void onProviderEnabled(String provider){}

			@Override
			public void onStatusChanged(String provider,int status,Bundle extras){}

		};
		this.lm.requestLocationUpdates(LocationManager.GPS_PROVIDER,1000,0,this.locationListener);
	}
    /**
     *
     * @return the current Location, or raise Exception if GPS is not running.
     */
	public Location getCurrentLocation(){
		this.currentLocation=this.lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);
		if (lm.isProviderEnabled(LocationManager.GPS_PROVIDER) != true) {
			throw new RuntimeException("GPS isn't running!");
		}
		return this.currentLocation;
	}
	/**
	 *
	 * @param latitude custom latitude in double.
	 * @param longitude custom longitude in double.
	 * @return the custom set location by given latitude, and the given longitude.
	 */

	public Location getCustomLocation(double latitude,double longitude){
		Location l=this.lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);
		if(l!=null){
			l.setLatitude(latitude);
			l.setLongitude(longitude);
		}
		return l;
	}

}