[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: [dm-devel] RFC: dm-switch target [v2]



On Wed, Aug 31, 2011 at 04:19:24PM -0400, Jim Ramsay wrote:
> Note: This is a repost with cleaned-up code, which was originally posted
> by Jason Shamberger.
>   http://www.redhat.com/archives/dm-devel/2011-March/msg00131.html
> 
> - The license in the headers has been cleared up - This is and always
>   has been GPL code.
> - Code formatting and style more closely match the Linux Kernel.
> 
> ---------------------------
> 
> We propose a new DM target, dm-switch, which can be used to efficiently
> implement a mapping of IOs to underlying block devices in scenarios
> where there are: (1) a large number of address regions, (2) a fixed size
> of these address regions, (3) no pattern than allows for a compact
> description with something like the dm-stripe target.
> 

Great, I've been waiting for this module :)

Do you guys have some userland tool/script to populate the page table
in dm-switch, or is there some other way to test this (with eql storage) ?

Thanks!

-- Pasi


> Motivation:
> 
> Dell EqualLogic and some other iSCSI storage arrays use a distributed
> frameless architecture.  In this architecture, the storage group
> consists of a number of distinct storage arrays ("members"), each having
> independent controllers, disk storage and network adapters.  When a LUN
> is created it is spread across multiple members.  The details of the
> spreading are hidden from initiators connected to this storage system.
> The storage group exposes a single target discovery portal, no matter
> how many members are being used.  When iSCSI sessions are created, each
> session is connected to an eth port on a single member.  Data to a LUN
> can be sent on any iSCSI session, and if the blocks being accessed are
> stored on another member the IO will be forwarded as required.  This
> forwarding is invisible to the initiator.  The storage layout is also
> dynamic, and the blocks stored on disk may be moved from member to
> member as needed to balance the load.
> 
> This architecture simplifies the management and configuration of both
> the storage group and initiators.  In a multipathing configuration, it
> is possible to set up multiple iSCSI sessions to use multiple network
> interfaces on both the host and target to take advantage of the
> increased network bandwidth.  An initiator can use a simple round robin
> algorithm to send IO on all paths and let the storage array members
> forward it as necessary.  However, there is a performance advantage to
> sending data directly to the correct member.  The Device Mapper table
> architecture supports designating different address regions with
> different targets.  However, in our architecture the LUN is spread with
> a chunk size on the order of 10s of MBs, which means the resulting DM
> table could have more than a million entries, which consumes too much
> memory.
> 
> Solution:
> 
> Based on earlier discussion with the dm-devel contributors, we have
> solved this problem by using Device Mapper to build a two-layer device
> hierarchy:
> 
>     Upper Tier ??? Determine which array member the IO should be sent to.
>     Lower Tier ??? Load balance amongst paths to a particular member.
> 
> The lower tier consists of a single multipath device for each member.
> Each of these multipath devices contains the set of paths directly to
> the array member in one priority group, and leverages existing path
> selectors to load balance amongst these paths.  We also build a
> non-preferred priority group containing paths to other array members for
> failover reasons.
> 
> The upper tier consists of a single switch device, using the new DM
> target module proposed here.  This device uses a bitmap to look up the
> location of the IO and choose the appropriate lower tier device to route
> the IO.  By using a bitmap we are able to use 4 bits for each address
> range in a 16 member group (which is very large for us).  This is a much
> denser representation than the DM table B-tree can achieve.
> 
> Though we have developed this target for a specific storage device, we
> have made an effort to keep it a general purpose as possible in hopes
> that others may benefit.  We welcome any feedback on the design or
> implementation.
> 
> --- dm-switch.h ---
> 
> /*
>  * Copyright (c) 2010-2011 by Dell, Inc.  All rights reserved.
>  *
>  * This file is released under the GPL.
>  *
>  * Description:
>  *
>  *     file:    dm-switch.h
>  *     authors: Kevin_OKelley dell com
>  *              Jim_Ramsay dell com
>  *              Narendran_Ganapathy dell com
>  *
>  * This file contains the netlink message definitions for the "switch" target.
>  *
>  * The only defined message at this time is for uploading the mapping page
>  * table.
>  */
> 
> #ifndef __DM_SWITCH_H
> #define __DM_SWITCH_H
> 
> #define MAX_IPC_MSG_LEN 65480	/* dictated by netlink socket */
> #define MAX_ERR_STR_LEN 255	/* maximum length of the error string */
> 
> enum Opcode {
> 	OPCODE_PAGE_TABLE_UPLOAD = 1,
> };
> 
> /*
>  * IPC Page Table message
>  */
> struct IpcPgTable {
> 	uint32_t total_len;	/* Total length of this IPC message */
> 	enum Opcode opcode;
> 	uint32_t userland[2];	/* Userland optional data (dmsetup status) */
> 	uint32_t dev_major;	/* DM device major */
> 	uint32_t dev_minor;	/* DM device minor */
> 	uint32_t page_total;	/* Total pages in the volume */
> 	uint32_t page_offset;	/* Starting page offset for this IPC */
> 	uint32_t page_count;	/* Number of page table entries in this IPC */
> 	uint32_t page_size;	/* Page size in 512B sectors */
> 	uint16_t dev_count;	/* Number of devices */
> 	uint8_t pte_bits;	/* Page Table Entry field size in bits */
> 	uint8_t reserved;	/* Integer alignment  */
> 	uint8_t ptbl_buff[1];	/* Page table entries (variable length) */
> };
> 
> /*
>  * IPC Response message
>  */
> struct IpcResponse {
> 	uint32_t total_len;	/* total length of the IPC */
> 	enum Opcode opcode;
> 	uint32_t userland[2];	/* Userland optional data */
> 	uint32_t dev_major;	/* DM device major */
> 	uint32_t dev_minor;	/* DM device minor */
> 	uint32_t status;	/* 0 on success; errno on failure */
> 	char err_str[MAX_ERR_STR_LEN + 1];
> 	/* If status != 0, contains an informative error message */
> };
> 
> /* Generic Netlink family attributes: used to define the family */
> enum {
> 	NETLINK_ATTR_UNSPEC,
> 	NETLINK_ATTR_MSG,
> 	NETLINK_ATTR__MAX,
> };
> #define NETLINK_ATTR_MAX (NETLINK_ATTR__MAX - 1)
> 
> /* Netlink commands (operations) */
> enum {
> 	NETLINK_CMD_UNSPEC,
> 	NETLINK_CMD_GET_PAGE_TBL,
> 	NETLINK_CMD__MAX,
> };
> #define NETLINK_CMD_MAX (NETLINK_CMD__MAX - 1)
> 
> #endif /* __DM_SWITCH_H */
> 
> --- dm-switch.c ---
> 
> /*
>  * Copyright (c) 2010-2011 by Dell, Inc.  All rights reserved.
>  *
>  * This file is released under the GPL.
>  *
>  * Description:
>  *
>  *     file:    dm-switch.c
>  *     authors: Kevin_OKelley dell com
>  *              Jim_Ramsay dell com
>  *              Narendran_Ganapathy dell com
>  *
>  * This file implements a "switch" target which efficiently implements a
>  * mapping of IOs to underlying block devices in scenarios where there are:
>  *   (1) a large number of address regions
>  *   (2) a fixed size equal across all address regions
>  *   (3) no pattern than allows for a compact description with something like
>  *       the dm-stripe target.
>  */
> 
> #include <linux/module.h>
> #include <linux/init.h>
> #include <linux/blkdev.h>
> #include <linux/bio.h>
> #include <linux/slab.h>
> #include <linux/device.h>
> #include <linux/version.h>
> #include <linux/dm-ioctl.h>
> #include <linux/device-mapper.h>
> #include <net/genetlink.h>
> #include <asm/div64.h>
> 
> #include "dm-switch.h"
> #define DM_MSG_PREFIX "switch"
> MODULE_DESCRIPTION(DM_NAME
> 		   " fixed-size address-region-mapping throughput-oriented path selector");
> MODULE_AUTHOR("Kevin D. O'Kelley <Kevin_OKelley dell com>");
> MODULE_LICENSE("GPL");
> 
> #if defined(DEBUG) || defined(_DEBUG)
> #define DBGPRINT(...)  printk(KERN_DEBUG #args)
> #define DBGPRINTV(...)
> /* #define DEBUG_HEXDUMP 1 */
> #else
> #define DBGPRINT(...)
> #define DBGPRINTV(...)
> #endif
> 
> /*
>  * Switch device context block: A new one is created for each dm device.
>  * Contains an array of devices from which we have taken references.
>  */
> struct switch_dev {
> 	struct dm_dev *dmdev;
> 	sector_t start;
> 	atomic_t error_count;
> };
> 
> /* Switch page table block */
> struct switch_ptbl {
> 	uint32_t pte_bits;	/* Page Table Entry field size in bits */
> 	uint32_t pte_mask;	/* Page Table Entry field mask */
> 	uint32_t pte_fields;	/* Number of Page Table Entries per uint32_t */
> 	uint32_t ptbl_bytes;	/* Page table size in bytes */
> 	uint32_t ptbl_num;	/* Page table size in entries */
> 	uint32_t ptbl_max;	/* Page table maximum size in entries; */
> 	uint32_t ptbl_buff[0];	/* Address of page table */
> };
> 
> /* Switch context header */
> struct switch_ctx {
> 	struct list_head list;
> 	dev_t dev_this;		/* Device serviced by this target */
> 	uint32_t dev_count;	/* Number of devices */
> 	uint32_t page_size;	/* Page size in 512B sectors */
> 	uint32_t userland[2];	/* Userland optional data (dmsetup status) */
> 	uint64_t ios_remapped;	/* I/Os remapped */
> 	uint64_t ios_unmapped;	/* I/Os not remapped */
> 	spinlock_t spinlock;	/* Control access to counters */
> 
> 	struct switch_ptbl *ptbl;	/* Page table (if loaded) */
> 	struct switch_dev dev_list[0];
> 	/* Array of dm devices to switch between */
> };
> 
> /*
>  * Global variables
>  */
> LIST_HEAD(__g_context_list);	/* Linked list of context blocks */
> static spinlock_t __g_spinlock;	/* Control access to list of context blocks */
> 
> /* Limit check for the switch constructor */
> static int switch_ctr_limits(struct dm_target *ti, struct dm_dev *dm)
> {
> 	struct block_device *sd = dm->bdev;
> 	struct hd_struct *hd = sd->bd_part;
> 	if (hd != NULL) {
> 		DBGPRINT("%s sd=0x%p (%d:%d), hd=0x%p, start=%llu, "
> 			 "size=%llu\n", __func__, sd, MAJOR(sd->bd_dev),
> 			 MINOR(sd->bd_dev), hd,
> 			 (unsigned long long)hd->start_sect,
> 			 (unsigned long long)hd->nr_sects);
> 		if (ti->len <= hd->nr_sects)
> 			return true;
> 		ti->error = "Device too small for target";
> 		return false;
> 	}
> 	ti->error = "Missing device limits";
> 	printk(KERN_WARNING "%s %s\n", __func__, ti->error);
> 	return true;
> }
> 
> /*
>  * Constructor: Called each time a dmsetup command creates a dm device.  The
>  * target parameter will already have the table, type, begin and len fields
>  * filled in.  Arguments are in pairs: <dev_path> <offset>.  Therefore, we get
>  * multiple constructor calls, but we will need to build a list of switch_ctx
>  * blocks so that the page table information gets matched to the correct
>  * device.
>  */
> static int switch_ctr(struct dm_target *ti, unsigned int argc, char **argv)
> {
> 	int n;
> 	uint32_t dev_count;
> 	unsigned long flags, major, minor;
> 	unsigned long long start;
> 	struct switch_ctx *pctx;
> 	struct mapped_device *md = NULL;
> 	struct dm_dev *dm;
> 	const char *dm_devname;
> 
> 	DBGPRINTV("%s\n", __func__);
> 	if (argc < 4) {
> 		ti->error = "Insufficient arguments";
> 		return -EINVAL;
> 	}
> 	if (kstrtou32(argv[0], 10, &dev_count) != 0) {
> 		ti->error = "Invalid device count";
> 		return -EINVAL;
> 	}
> 	if (dev_count != (argc - 2) / 2) {
> 		ti->error = "Invalid argument count";
> 		return -EINVAL;
> 	}
> 	pctx = kmalloc(sizeof(*pctx) + (dev_count * sizeof(struct switch_dev)),
> 		       GFP_KERNEL);
> 	if (pctx == NULL) {
> 		ti->error = "Cannot allocate redirect context";
> 		return -ENOMEM;
> 	}
> 	pctx->dev_count = dev_count;
> 	if ((kstrtou32(argv[1], 10, &pctx->page_size) != 0) ||
> 	    (pctx->page_size == 0)) {
> 		ti->error = "Invalid page size";
> 		goto failed_kfree;
> 	}
> 	pctx->ptbl = NULL;
> 	pctx->userland[0] = pctx->userland[1] = 0;
> 	pctx->ios_remapped = pctx->ios_unmapped = 0;
> 	spin_lock_init(&pctx->spinlock);
> 
> 	/*
> 	 * Find the device major and minor for the device that is being served
> 	 * by this target.
> 	 */
> 	md = dm_table_get_md(ti->table);
> 	if (md == NULL) {
> 		ti->error = "Cannot locate dm device";
> 		goto failed_kfree;
> 	}
> 	dm_devname = dm_device_name(md);
> 	if (dm_devname == NULL) {
> 		ti->error = "Cannot acquire dm device name";
> 		goto failed_kfree;
> 	}
> 	if (sscanf(dm_devname, "%lu:%lu", &major, &minor) != 2) {
> 		ti->error = "Invalid dm device name";
> 		goto failed_kfree;
> 	}
> 	pctx->dev_this = MKDEV(major, minor);
> 	DBGPRINT("%s ctx=0x%p (%d:%d), type=\"%s\", count=%d, "
> 		 "start=%llu, size=%llu\n",
> 		 __func__, pctx, MAJOR(pctx->dev_this),
> 		 MINOR(pctx->dev_this), ti->type->name, pctx->dev_count,
> 		 (unsigned long long)ti->begin, (unsigned long long)ti->len);
> 
> 	/*
> 	 * Check each device beneath the target to ensure that the limits are
> 	 * consistent.
> 	 */
> 	for (n = 0, argc = 2; n < pctx->dev_count; n++, argc += 2) {
> 		DBGPRINTV("%s #%d 0x%p, %s, %s\n", __func__, n,
> 			  &pctx->dev_list[n], argv[argc], argv[argc + 1]);
> 		if (sscanf(argv[argc + 1], "%llu", &start) != 1) {
> 			ti->error = "Invalid device starting offset";
> 			goto failed_dev_list_prev;
> 		}
> 		if (dm_get_device
> 		    (ti, argv[argc], dm_table_get_mode(ti->table), &dm)) {
> 			ti->error = "Device lookup failed";
> 			goto failed_dev_list_prev;
> 		}
> 		pctx->dev_list[n].dmdev = dm;
> 		pctx->dev_list[n].start = start;
> 		atomic_set(&(pctx->dev_list[n].error_count), 0);
> 		if (!switch_ctr_limits(ti, dm))
> 			goto failed_dev_list_all;
> 	}
> 
> 	spin_lock_irqsave(&__g_spinlock, flags);
> 	list_add_tail(&pctx->list, &__g_context_list);
> 	spin_unlock_irqrestore(&__g_spinlock, flags);
> 	ti->private = pctx;
> 	return 0;
> 
> failed_dev_list_prev:		/* De-reference previous devices */
> 	n--;			/*   (i.e. don't include this one) */
> 
> failed_dev_list_all:		/* De-reference all devices  */
> 	printk(KERN_WARNING "%s device=%s, start=%s\n", __func__,
> 	       argv[argc], argv[argc + 1]);
> 	for (; n >= 0; n--)
> 		dm_put_device(ti, pctx->dev_list[n].dmdev);
> 
> failed_kfree:
> 	printk(KERN_WARNING "%s %s\n", __func__, ti->error);
> 	kfree(pctx);
> 	return -EINVAL;
> }
> 
> /*
>  * Destructor: Don't free the dm_target, just the ti->private data (if any).
>  */
> static void switch_dtr(struct dm_target *ti)
> {
> 	int n;
> 	unsigned long flags;
> 	struct switch_ctx *pctx = (struct switch_ctx *)ti->private;
> 	void *ptbl;
> 
> 	DBGPRINT("%s ctx=0x%p (%d:%d)\n", __func__, pctx,
> 		 MAJOR(pctx->dev_this), MINOR(pctx->dev_this));
> 	spin_lock_irqsave(&__g_spinlock, flags);
> 	ptbl = pctx->ptbl;
> 	rcu_assign_pointer(pctx->ptbl, NULL);
> 	list_del(&pctx->list);
> 	spin_unlock_irqrestore(&__g_spinlock, flags);
> 	for (n = 0; n < pctx->dev_count; n++) {
> 		DBGPRINTV("%s dm_put_device(%s)\n", __func__,
> 			  pctx->dev_list[n].dmdev->name);
> 		dm_put_device(ti, pctx->dev_list[n].dmdev);
> 	}
> 	synchronize_rcu();
> 	kfree(ptbl);
> 	kfree(pctx);
> }
> 
> /*
>  * NOTE: If CONFIG_LBD is disabled, sector_t types are uint32_t.  Therefore, in
>  * this routine, we convert the offset into a uint64_t instead of a sector_t so
>  * that all of the remaining arithmatic is correct, including the do_div()
>  * calls.
>  */
> static int switch_map(struct dm_target *ti, struct bio *bio,
> 		      union map_info *map_context)
> {
> 	struct switch_ctx *pctx = (struct switch_ctx *)ti->private;
> 	struct switch_ptbl *ptbl;
> 	unsigned long flags;
> 	uint64_t itbl, offset = bio->bi_sector - ti->begin;
> 	uint32_t idev = 0, irem;
> 	uint64_t *pinc = &pctx->ios_unmapped;
> 
> 	rcu_read_lock();
> 	ptbl = rcu_dereference(pctx->ptbl);
> 	if (ptbl != NULL) {
> 		itbl = offset;
> 		do_div(itbl, pctx->page_size);
> 		if (itbl < ptbl->ptbl_num) {
> 			irem = do_div(itbl, ptbl->pte_fields);
> 			idev =
> 			    (ptbl->ptbl_buff[itbl] >> (irem * ptbl->pte_bits))
> 			    & ptbl->pte_mask;
> 			if (idev <= pctx->dev_count) {
> 				pinc = &pctx->ios_remapped;
> 			} else {
> 				printk(KERN_WARNING "%s WARNING: dev=%d, "
> 				       "offset=%lld\n", __func__, idev, offset);
> 				idev = 0;
> 			}
> 		} else {
> 			printk(KERN_WARNING "%s WARNING: Page Table Entry "
> 			       "%lld >= %d\n", __func__, itbl, ptbl->ptbl_num);
> 		}
> 	}
> 	rcu_read_unlock();
> 	spin_lock_irqsave(&pctx->spinlock, flags);
> 	(*pinc)++;
> 	spin_unlock_irqrestore(&pctx->spinlock, flags);
> 	bio->bi_bdev = pctx->dev_list[idev].dmdev->bdev;
> 	bio->bi_sector = pctx->dev_list[idev].start + offset;
> 	return DM_MAPIO_REMAPPED;
> }
> 
> /*
>  * Switch status:
>  *
>  * INFO: #dev_count device [device] 5 'A'['A' ...] userland[0] userland[1]
>  *       #remapped #unmapped
>  *
>  * where:
>  *   "'A'['A']" is a single word with an 'A' (active) or 'D' for each device
>  *   The userland values are set by the last userland message to load the page
>  *   table
>  *   "#remapped" is the number of remapped I/Os
>  *   "#unmapped" is the number of I/Os that could not be remapped
>  *
>  * TABLE: #page_size #dev_count device start [device start ...]
>  */
> static int switch_status(struct dm_target *ti, status_type_t type, char
> 			 *result, unsigned int maxlen)
> {
> 	struct switch_ctx *pctx = (struct switch_ctx *)ti->private;
> 	char buffer[pctx->dev_count + 1];
> 	unsigned int sz = 0;
> 	int n;
> 	uint64_t remapped, unmapped;
> 	unsigned long flags;
> 
> 	result[0] = '\0';
> 	switch (type) {
> 	case STATUSTYPE_INFO:
> 		DMEMIT("%d", pctx->dev_count);
> 		for (n = 0; n < pctx->dev_count; n++) {
> 			DMEMIT(" %s", pctx->dev_list[n].dmdev->name);
> 			buffer[n] = 'A';
> 		}
> 		buffer[n] = '\0';
> 		spin_lock_irqsave(&pctx->spinlock, flags);
> 		remapped = pctx->ios_remapped;
> 		unmapped = pctx->ios_unmapped;
> 		spin_unlock_irqrestore(&pctx->spinlock, flags);
> 		DMEMIT(" 5 %s %08x %08x %lld %lld", buffer, pctx->userland[0],
> 		       pctx->userland[1], remapped, unmapped);
> 		break;
> 
> 	case STATUSTYPE_TABLE:
> 		DMEMIT("%d %d", pctx->dev_count, pctx->page_size);
> 		for (n = 0; n < pctx->dev_count; n++) {
> 			DMEMIT(" %s %llu", pctx->dev_list[n].dmdev->name,
> 			       (unsigned long long)pctx->dev_list[n].start);
> 		}
> 		break;
> 
> 	default:
> 		return 0;
> 	}
> 	return 0;
> }
> 
> /*
>  * Switch ioctl:
>  *
>  * Passthrough all ioctls to the first path.
>  */
> static int switch_ioctl(struct dm_target *ti, unsigned int cmd,
> 			unsigned long arg)
> {
> 	struct switch_ctx *pctx = (struct switch_ctx *)ti->private;
> 	struct block_device *bdev;
> 	fmode_t mode = 0;
> 
> 	/* Sanity check */
> 	if (unlikely(!pctx || !pctx->dev_list[0].dmdev ||
> 		     !pctx->dev_list[0].dmdev->bdev))
> 		return -EIO;
> 
> 	bdev = pctx->dev_list[0].dmdev->bdev;
> 	mode = pctx->dev_list[0].dmdev->mode;
> 	return __blkdev_driver_ioctl(bdev, mode, cmd, arg);
> }
> 
> static struct target_type __g_switch_target = {
> 	.name = "switch",
> 	.version = {1, 0, 0},
> 	.module = THIS_MODULE,
> 	.ctr = switch_ctr,
> 	.dtr = switch_dtr,
> 	.map = switch_map,
> 	.status = switch_status,
> 	.ioctl = switch_ioctl,
> };
> 
> /* Generic Netlink attribute policy (single attribute, NETLINK_ATTR_MSG) */
> static struct nla_policy __g_attr_policy[NETLINK_ATTR_MAX + 1] = {
> 	[NETLINK_ATTR_MSG] = {.type = NLA_BINARY,.len = MAX_IPC_MSG_LEN},
> };
> 
> /* Define the Generic Netlink family */
> static struct genl_family __g_family = {
> 	.id = GENL_ID_GENERATE,	/* Assign channel when family is registered */
> 	.hdrsize = 0,
> 	.name = "DM_SWITCH",
> 	.version = 1,
> 	.maxattr = NETLINK_ATTR_MAX,
> };
> 
> #ifdef DEBUG_HEXDUMP
> #define DEBUG_HEXDUMP_WORDS 8
> #define DEBUG_HEXDUMP_BYTES (DEBUG_HEXDUMP_WORDS * sizeof(uint32_t))
> 
> static inline void debug_hexdump_line(void *ibuff, size_t offset, size_t isize,
> 				      const char *func)
> {
> 	static const char *hex = "0123456789abcdef";
> 	unsigned char *iptr = &((unsigned char *)ibuff)[offset];
> 	char *optr, obuff[DEBUG_HEXDUMP_BYTES * 3];
> 	int osize;
> 
> 	while (isize > 0) {
> 		optr = obuff;
> 		for (osize = 0; osize < DEBUG_HEXDUMP_BYTES; osize++) {
> 			if (((osize & 3) == 0) && (osize != 0))
> 				*optr++ = ' ';
> 			*optr++ = hex[(*iptr) >> 4];
> 			*optr++ = hex[(*iptr++) & 15];
> 			if (--isize <= 0)
> 				break;
> 		}
> 		*optr = '\0';
> 		DBGPRINT("%s %04x %s\n", func, (unsigned int)offset, obuff);
> 		offset += DEBUG_HEXDUMP_BYTES;
> 	}
> }
> 
> static inline void debug_hexdump(void *ibuff, size_t isize, const char *func)
> {
> 	size_t iline = isize / DEBUG_HEXDUMP_BYTES;
> 	size_t irem = isize % DEBUG_HEXDUMP_BYTES;
> 	size_t offset = isize;
> 
> 	if (iline < 6) {
> 		debug_hexdump_line(ibuff, 0, isize, func);
> 		return;
> 	}
> 	debug_hexdump_line(ibuff, 0, (3 * DEBUG_HEXDUMP_BYTES), func);
> 	isize = (irem == 0) ? (3 * DEBUG_HEXDUMP_BYTES)
> 	    : ((2 * DEBUG_HEXDUMP_BYTES) + irem);
> 	offset -= isize;
> 	debug_hexdump_line(ibuff, offset, isize, func);
> }
> #else
> static inline void debug_hexdump(void *ibuff, size_t isize, const char *func)
> {
> }
> #endif
> 
> /*
>  * Generic Netlink socket read function that handles communication from the
>  * userland for downloading the page table.
>  */
> static int get_page_tbl(struct sk_buff *skb_2, struct genl_info *info)
> {
> 	uint32_t rc, pte_mask, pte_fields, ptbl_bytes, offset, size;
> 	uint32_t status = 0;
> 	unsigned long flags;
> 	char *mydata;
> 	void *msg_head;
> 	struct nlattr *na;
> 	struct sk_buff *skb;
> 	struct switch_ctx *pctx, *next;
> 	struct switch_ptbl *ptbl, *pnew;
> 	struct IpcPgTable *pgp;
> 	struct IpcResponse resp;
> 	dev_t dev;
> 	static const char *invmsg = "Invalid Page Table message";
> 
> 	/*
> 	 * For each attribute there is an index in info->attrs which points to
> 	 * a nlattr structure in this structure the data is given
> 	 */
> 	if (info == NULL) {
> 		printk(KERN_WARNING "%s missing genl_info parameter\n",
> 		       __func__);
> 		return 0;
> 	}
> 	na = info->attrs[NETLINK_ATTR_MSG];
> 	if (na == NULL) {
> 		printk(KERN_WARNING "%s no info->attrs %i\n", __func__,
> 		       NETLINK_ATTR_MSG);
> 		return 0;
> 	}
> 	mydata = (char *)nla_data(na);
> 	if (mydata == NULL) {
> 		printk(KERN_WARNING "%s error while receiving data\n",
> 		       __func__);
> 		return 0;
> 	}
> 	DBGPRINTV("%s seq=%d, pid=%d, type=%d, flags=0x%x, data=0x%p "
> 		  "(0x%x, %d)\n",
> 		  __func__, info->snd_seq, info->snd_pid,
> 		  info->nlhdr->nlmsg_type, info->nlhdr->nlmsg_flags,
> 		  mydata, na->nla_len, na->nla_len);
> 	debug_hexdump(mydata,
> 		      ((offsetof(struct IpcPgTable, ptbl_buff)<na->nla_len)
> 		       ? offsetof(struct IpcPgTable, ptbl_buff)
> 		       : na->nla_len), __func__);
> 	/*
> 	 * Format the reply message.  Return positve error codes to userland.
> 	 */
> 	skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
> 	if (skb == NULL) {
> 		printk(KERN_WARNING "%s cannot allocate reply message\n",
> 		       __func__);
> 		return 0;
> 	}
> 	msg_head = genlmsg_put(skb, 0, info->snd_seq, &__g_family, 0,
> 			       NETLINK_CMD_GET_PAGE_TBL);
> 	if (skb == NULL) {
> 		printk(KERN_WARNING "%s cannot format reply message header\n",
> 		       __func__);
> 		return 0;
> 	}
> 	pgp = (struct IpcPgTable *)mydata;
> 	if (na->nla_len < sizeof(struct IpcPgTable)) {
> 		snprintf(resp.err_str, sizeof(resp.err_str),
> 			 "%s: too short (%d)", invmsg, na->nla_len);
> 		status = EINVAL;
> 		goto failed_respond;
> 	}
> 	if ((pgp->page_offset + pgp->page_count) > pgp->page_total) {
> 		snprintf(resp.err_str, sizeof(resp.err_str),
> 			 "%s: too many page table entries (%d > %d)",
> 			 invmsg, (pgp->page_offset + pgp->page_count),
> 			 pgp->page_total);
> 		status = EINVAL;
> 		goto failed_respond;
> 	}
> 	pte_mask = (1 << pgp->pte_bits) - 1;
> 	if (((pgp->dev_count - 1) & (~pte_mask)) != 0) {
> 		snprintf(resp.err_str, sizeof(resp.err_str),
> 			 "%s: invalid mask 0x%x for %d devices",
> 			 invmsg, pte_mask, pgp->dev_count);
> 		status = EINVAL;
> 		goto failed_respond;
> 	}
> 	pte_fields = 32 / pgp->pte_bits;
> 	size = ((pgp->page_count + pte_fields - 1) / pte_fields) *
> 	    sizeof(uint32_t);
> 	if ((sizeof(*pgp) - 1 + size) > na->nla_len) {
> 		snprintf(resp.err_str, sizeof(resp.err_str),
> 			 "Invalid Page Table message: incomplete messsage");
> 		status = EINVAL;
> 		goto failed_respond;
> 	}
> 	debug_hexdump(&pgp->ptbl_buff, size, __func__);
> 
> 	/*
> 	 * Look for the corresponding switch context block to create or update
> 	 * the page table.
> 	 */
> 	rc = 0;
> 	dev = MKDEV(pgp->dev_major, pgp->dev_minor);
> 	spin_lock_irqsave(&__g_spinlock, flags);
> 	list_for_each_entry_safe(pctx, next, &__g_context_list, list) {
> 		if (dev == pctx->dev_this) {
> 			rc = 1;
> 			break;
> 		}
> 	}
> 	if (rc == 0) {
> 		snprintf(resp.err_str, sizeof(resp.err_str),
> 			 "%s: invalid target device %d:%d",
> 			 invmsg, pgp->dev_major, pgp->dev_minor);
> 		status = EINVAL;
> 		goto failed_unlock;
> 	}
> 	DBGPRINTV("%s ctx=0x%p (%d:%d)\n", __func__, pctx, pgp->dev_major,
> 		  pgp->dev_minor);
> 
> 	ptbl = pctx->ptbl;
> 	if (((ptbl != NULL) && (pgp->page_offset > (ptbl->ptbl_num + 1))) ||
> 	    ((ptbl == NULL) && (pgp->page_offset != 0))) {
> 		snprintf(resp.err_str, sizeof(resp.err_str),
> 			 "%s: missing entries", invmsg);
> 		status = EINVAL;
> 		goto failed_unlock;
> 	}
> 	/*
> 	 * Don't allow userland to change context parameters unless the page
> 	 * table is being rebuilt.
> 	 */
> 	if (pgp->page_offset != 0) {
> 		if ((pgp->dev_count) != pctx->dev_count) {
> 			snprintf(resp.err_str, sizeof(resp.err_str),
> 				 "%s: invalid device count %d",
> 				 invmsg, pgp->dev_count);
> 			status = EINVAL;
> 			goto failed_respond;
> 		}
> 		if (ptbl != NULL) {
> 			if (pgp->pte_bits != ptbl->pte_bits) {
> 				snprintf(resp.err_str, sizeof(resp.err_str),
> 					 "%s: number of bits changed", invmsg);
> 				status = EINVAL;
> 				goto failed_unlock;
> 			}
> 			if (pgp->page_total != ptbl->ptbl_max) {
> 				snprintf(resp.err_str, sizeof(resp.err_str),
> 					 "%s: total number of entries changed",
> 					 invmsg);
> 				status = EINVAL;
> 				goto failed_unlock;
> 			}
> 		}
> 	}
> 
> 	/*
> 	 * Create a Page Table if needed.  Most of the time, the size of the
> 	 * table doesn't change.  In that case, re-use the existing table.
> 	 */
> 	ptbl_bytes = ((pgp->page_total + pte_fields - 1) / pte_fields) *
> 	    sizeof(uint32_t);
> 	if ((ptbl != NULL) && (ptbl_bytes == ptbl->ptbl_bytes)) {
> 		pnew = ptbl;
> 	} else {
> 		pnew = kmalloc((sizeof(*pnew) + ptbl_bytes), GFP_KERNEL);
> 		if (pnew == NULL) {
> 			snprintf(resp.err_str, sizeof(resp.err_str),
> 				 "Cannot allocate Page Table");
> 			status = EINVAL;
> 			goto failed_unlock;
> 		}
> 		pnew->ptbl_bytes = ptbl_bytes;
> 		DBGPRINT("%s ctx=0x%p (%d:%d) pnew=0x%p, buff=0x%p (%d), OK\n",
> 			 __func__, pctx, MAJOR(pctx->dev_this),
> 			 MINOR(pctx->dev_this), pnew, pnew->ptbl_buff,
> 			 ptbl_bytes);
> 	}
> 	pnew->pte_bits = pgp->pte_bits;
> 	pnew->pte_mask = pte_mask;
> 	pnew->pte_fields = pte_fields;
> 	pnew->ptbl_max = pgp->page_total;
> 	pnew->ptbl_num = pgp->page_offset + pgp->page_count;
> 	DBGPRINT("%s ctx=0x%p (%d:%d): bits=%d, mask=0x%x, num=%d, max=%d\n",
> 		 __func__, pctx, MAJOR(pctx->dev_this),
> 		 MINOR(pctx->dev_this), pnew->pte_bits, pnew->pte_mask,
> 		 pnew->ptbl_num, pnew->ptbl_max);
> 	offset = (pgp->page_offset + pte_fields - 1) / pte_fields;
> 	memcpy(&pnew->ptbl_buff[offset], pgp->ptbl_buff, size);
> 	pctx->userland[0] = pgp->userland[0];
> 	pctx->userland[1] = pgp->userland[1];
> 
> 	if (pnew != ptbl) {
> 		rcu_assign_pointer(pctx->ptbl, pnew);
> 		kfree(ptbl);
> 	}
> 
> failed_unlock:
> 	spin_unlock_irqrestore(&__g_spinlock, flags);
> 
> failed_respond:
> 	if (status)
> 		printk(KERN_WARNING "%s WARNING: %s\n", __func__, resp.err_str);
> 	else
> 		resp.err_str[0] = '\0';
> 
> 	/* Format the response message */
> 	resp.total_len = sizeof(struct IpcResponse);
> 	resp.opcode = OPCODE_PAGE_TABLE_UPLOAD;
> 	resp.userland[0] = pgp->userland[0];
> 	resp.userland[1] = pgp->userland[1];
> 	resp.dev_major = pgp->dev_major;
> 	resp.dev_minor = pgp->dev_minor;
> 	resp.status = status;
> 	rc = nla_put(skb, NLA_BINARY, sizeof(struct IpcResponse), &resp);
> 	if (rc != 0) {
> 		printk(KERN_WARNING
> 		       "%s WARNING: Cannot format reply message\n", __func__);
> 		return 0;
> 	}
> 	genlmsg_end(skb, msg_head);
> 	rc = genlmsg_unicast(&init_net, skb, info->snd_pid);
> 	if (rc != 0)
> 		printk(KERN_WARNING "%s WARNING: Cannot send reply message\n",
> 		       __func__);
> 	return 0;
> }
> 
> /* Operation for getting the page table */
> static struct genl_ops __g_op_get_page_tbl = {
> 	.cmd = NETLINK_CMD_GET_PAGE_TBL,
> 	.flags = 0,
> 	.policy = __g_attr_policy,
> 	.doit = get_page_tbl,
> 	.dumpit = NULL,
> };
> 
> /*
>  * Use the sysfs interface to inform the userland process of the family id to
>  * be used by the Generic Netlink socket.
>  */
> static ssize_t sysfs_familyid_show(struct kobject *kobj,
> 				   struct attribute *attr, char *buff)
> {
> 	return snprintf(buff, PAGE_SIZE, "%d", __g_family.id);
> }
> 
> static ssize_t sysfs_familyid_store(struct kobject *kobj,
> 				    struct attribute *attr, const char *buff,
> 				    size_t size)
> {
> 	return size;
> }
> 
> struct _sysfs_attr_ops {
> 	const struct attribute attr;
> 	const struct sysfs_ops ops;
> };
> static const struct _sysfs_attr_ops __g_sysfs_familyid = {
> 	.attr = {"familyid", 0644},
> 	.ops = {&sysfs_familyid_show, &sysfs_familyid_store}
> };
> 
> int __init dm_switch_init(void)
> {
> 	int r;
> 
> 	DBGPRINTV("%s\n", __func__);
> 	spin_lock_init(&__g_spinlock);
> 	r = dm_register_target(&__g_switch_target);
> 	if (r) {
> 		DMERR("dm_register_target() failed %d", r);
> 		return r;
> 	}
> 
> 	/* Initialize Generic Netlink communications */
> 	r = genl_register_family(&__g_family);
> 	if (r) {
> 		DMERR("genl_register_family() failed");
> 		goto failed;
> 	}
> 	r = genl_register_ops(&__g_family, &__g_op_get_page_tbl);
> 	if (r) {
> 		DMERR("genl_register_ops(get_page_tbl) failed %d", r);
> 		goto failed;
> 	}
> 	DBGPRINTV("%s Registered Generic Netlink group %d\n", __func__,
> 		  __g_family.id);
> 	r = sysfs_create_file(&__g_switch_target.module->mkobj.kobj,
> 			      &__g_sysfs_familyid.attr);
> 	if (r) {
> 		DMERR("/sys/module/familyid create failed %d", r);
> 		goto failed;
> 	}
> 	return 0;
> 
> failed:
> 	dm_unregister_target(&__g_switch_target);
> 	return r;
> }
> 
> void dm_switch_exit(void)
> {
> 	int r;
> 
> 	DBGPRINTV("%s\n", __func__);
> 	dm_unregister_target(&__g_switch_target);
> 	r = genl_unregister_family(&__g_family);
> 	if (r)
> 		DMWARN("genl_unregister_family() failed %d", r);
> 	return;
> }
> 
> module_init(dm_switch_init);
> module_exit(dm_switch_exit);
> 
> --
> dm-devel mailing list
> dm-devel redhat com
> https://www.redhat.com/mailman/listinfo/dm-devel


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]