自学教程：C++ xenbus_printf函数代码示例

void shutdown_netfront(struct netfront_dev *dev){    char* err;    char *nodename = dev->nodename;    char path[strlen(dev->backend) + 1 + 5 + 1];    printk("close network: backend at %s/n",dev->backend);    snprintf(path, sizeof(path), "%s/state", dev->backend);    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 5); /* closing */    xenbus_wait_for_value(path, "5", &dev->events);    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 6);    xenbus_wait_for_value(path, "6", &dev->events);    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);    xenbus_wait_for_value(path, "2", &dev->events);    xenbus_unwatch_path(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/tx-ring-ref", nodename);    xenbus_rm(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/rx-ring-ref", nodename);    xenbus_rm(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/event-channel", nodename);    xenbus_rm(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/request-rx-copy", nodename);    xenbus_rm(XBT_NIL, path);    free_netfront(dev);}

void shutdown_kbdfront(struct kbdfront_dev *dev){    char* err;    char *nodename = dev->nodename;    char path[strlen(dev->backend) + 1 + 5 + 1];    printk("close kbd: backend at %s/n",dev->backend);    snprintf(path, sizeof(path), "%s/state", dev->backend);    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 5); /* closing */    xenbus_wait_for_value(path, "5", &dev->events);    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 6);    xenbus_wait_for_value(path, "6", &dev->events);    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);    // does not work yet.    //xenbus_wait_for_value(path, "2", &dev->events);    xenbus_unwatch_path(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/page-ref", nodename);    xenbus_rm(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/event-channel", nodename);    xenbus_rm(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/request-abs-pointer", nodename);    xenbus_rm(XBT_NIL, path);    free_kbdfront(dev);}

static int svm_grant_ring(int arg){	int ret, gnt_ref;	struct xenbus_device dev;	printk(KERN_ALERT "[svm]: arg is:%d/n", arg);	dev.otherend_id = arg;	if(NULL == vaddr){		printk(KERN_ALERT "[svm]: wrong vaddr./n");		return -1;	}	gnt_ref = xenbus_grant_ring(&dev, virt_to_mfn(vaddr));	if(gnt_ref < 0){		printk(KERN_ALERT "[svm]: grant ring failed!/n");		return -1;	}		xenbus_printf(XBT_NIL, "/vrv/svm/grant_table", "com", "pos:0 len:0");	xenbus_printf(XBT_NIL, "/vrv/svm", "grant_table", "%d", gnt_ref);	printk(KERN_ALERT "[svm]: grant table to %d, gnt_ref is:%d./n", dev.otherend_id, gnt_ref);	return 0;}

void shutdown_fbfront(struct fbfront_dev *dev){    char* err;    char *nodename = dev->nodename;    char path[strlen(dev->backend) + 1 + 5 + 1];    printk("close fb: backend at %s/n",dev->backend);    snprintf(path, sizeof(path), "%s/state", dev->backend);    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 5); /* closing */    xenbus_wait_for_value(path, "5", &dev->events);    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 6);    xenbus_wait_for_value(path, "6", &dev->events);    err = xenbus_printf(XBT_NIL, nodename, "state", "%u", 1);    // does not work yet    //xenbus_wait_for_value(path, "2", &dev->events);    xenbus_unwatch_path(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/page-ref", nodename);    xenbus_rm(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/event-channel", nodename);    xenbus_rm(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/protocol", nodename);    xenbus_rm(XBT_NIL, path);    snprintf(path, sizeof(path), "%s/feature-update", nodename);    xenbus_rm(XBT_NIL, path);    unbind_evtchn(dev->evtchn);    free_fbfront(dev);}

static int pcifront_publish_info(struct pcifront_device *pdev){	int err = 0;	struct xenbus_transaction trans;	err = xenbus_grant_ring(pdev->xdev, virt_to_mfn(pdev->sh_info));	if (err < 0)		goto out;	pdev->gnt_ref = err;	err = xenbus_alloc_evtchn(pdev->xdev, &pdev->evtchn);	if (err)		goto out;	bind_caller_port_to_irqhandler(pdev->evtchn, pcifront_handler_aer, 		IRQF_SAMPLE_RANDOM, "pcifront", pdev);      do_publish:	err = xenbus_transaction_start(&trans);	if (err) {		xenbus_dev_fatal(pdev->xdev, err,				 "Error writing configuration for backend "				 "(start transaction)");		goto out;	}	err = xenbus_printf(trans, pdev->xdev->nodename,			    "pci-op-ref", "%u", pdev->gnt_ref);	if (!err)		err = xenbus_printf(trans, pdev->xdev->nodename,				    "event-channel", "%u", pdev->evtchn);	if (!err)		err = xenbus_printf(trans, pdev->xdev->nodename,				    "magic", XEN_PCI_MAGIC);	if (err) {		xenbus_transaction_end(trans, 1);		xenbus_dev_fatal(pdev->xdev, err,				 "Error writing configuration for backend");		goto out;	} else {		err = xenbus_transaction_end(trans, 0);		if (err == -EAGAIN)			goto do_publish;		else if (err) {			xenbus_dev_fatal(pdev->xdev, err,					 "Error completing transaction "					 "for backend");			goto out;		}	}	xenbus_switch_state(pdev->xdev, XenbusStateInitialised);	dev_dbg(&pdev->xdev->dev, "publishing successful!/n");      out:	return err;}

static int talk_to_backend(struct xenbus_device *dev,			   struct usbfront_info *info){	const char *message;	struct xenbus_transaction xbt;	int err;	err = setup_rings(dev, info);	if (err)		goto out;again:	err = xenbus_transaction_start(&xbt);	if (err) {		xenbus_dev_fatal(dev, err, "starting transaction");		goto destroy_ring;	}	err = xenbus_printf(xbt, dev->nodename, "urb-ring-ref", "%u",			    info->urb_ring_ref);	if (err) {		message = "writing urb-ring-ref";		goto abort_transaction;	}	err = xenbus_printf(xbt, dev->nodename, "conn-ring-ref", "%u",			    info->conn_ring_ref);	if (err) {		message = "writing conn-ring-ref";		goto abort_transaction;	}	err = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",			    irq_to_evtchn_port(info->irq));	if (err) {		message = "writing event-channel";		goto abort_transaction;	}	err = xenbus_transaction_end(xbt, 0);	if (err) {		if (err == -EAGAIN)			goto again;		xenbus_dev_fatal(dev, err, "completing transaction");		goto destroy_ring;	}	return 0;abort_transaction:	xenbus_transaction_end(xbt, 1);	xenbus_dev_fatal(dev, err, "%s", message);destroy_ring:	destroy_rings(info);out:	return err;}

/* Common code used when first setting up, and when resuming. */static int talk_to_ixpback(struct xenbus_device *dev,			   struct ixpfront_info *info){	const char *message = NULL;	struct xenbus_transaction xbt;	int err;	/* Create shared ring, alloc event channel. */	err = setup_ixpring(dev, info);	if (err)		goto out;again:	err = xenbus_transaction_start(&xbt);	if (err) {		xenbus_dev_fatal(dev, err, "starting transaction");		goto destroy_ixpring;	}	err = xenbus_printf(xbt, dev->nodename,			    "ring-ref", "%u", info->ring_ref);	if (err) {		message = "writing ring-ref";		goto abort_transaction;	}	err = xenbus_printf(xbt, dev->nodename,			    "event-channel", "%u", info->evtchn);	if (err) {		message = "writing event-channel";		goto abort_transaction;	}	err = xenbus_printf(xbt, dev->nodename, "protocol", "%s",			    XEN_IO_PROTO_ABI_NATIVE);	if (err) {		message = "writing protocol";		goto abort_transaction;	}	err = xenbus_transaction_end(xbt, 0);	if (err) {		if (err == -EAGAIN)			goto again;		xenbus_dev_fatal(dev, err, "completing transaction");		goto destroy_ixpring;	}	xenbus_switch_state(dev, XenbusStateInitialised);	return 0; abort_transaction:	xenbus_transaction_end(xbt, 1);	if (message)		xenbus_dev_fatal(dev, err, "%s", message); destroy_ixpring:	ixp_free(info, 0); out:	return err;}

static int xen_pcibk_publish_pci_root(struct xen_pcibk_device *pdev,				    unsigned int domain, unsigned int bus){	unsigned int d, b;	int i, root_num, len, err;	char str[64];	dev_dbg(&pdev->xdev->dev, "Publishing pci roots/n");	err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename,			   "root_num", "%d", &root_num);	if (err == 0 || err == -ENOENT)		root_num = 0;	else if (err < 0)		goto out;	/* Verify that we haven't already published this pci root */	for (i = 0; i < root_num; i++) {		len = snprintf(str, sizeof(str), "root-%d", i);		if (unlikely(len >= (sizeof(str) - 1))) {			err = -ENOMEM;			goto out;		}		err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename,				   str, "%x:%x", &d, &b);		if (err < 0)			goto out;		if (err != 2) {			err = -EINVAL;			goto out;		}		if (d == domain && b == bus) {			err = 0;			goto out;		}	}	len = snprintf(str, sizeof(str), "root-%d", root_num);	if (unlikely(len >= (sizeof(str) - 1))) {		err = -ENOMEM;		goto out;	}	dev_dbg(&pdev->xdev->dev, "writing root %d at %04x:%02x/n",		root_num, domain, bus);	err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, str,			    "%04x:%02x", domain, bus);	if (err)		goto out;	err = xenbus_printf(XBT_NIL, pdev->xdev->nodename,			    "root_num", "%d", (root_num + 1));out:	return err;}

/** * Write the physical details regarding the block device to the store, and * switch to Connected state. */static void connect(struct backend_info *be){	xenbus_transaction_t xbt;	int err;	struct xenbus_device *dev = be->dev;	DPRINTK("%s", dev->otherend);	/* Supply the information about the device the frontend needs */again:	err = xenbus_transaction_start(&xbt);	if (err) {		xenbus_dev_fatal(dev, err, "starting transaction");		return;	}	err = xenbus_printf(xbt, dev->nodename, "sectors", "%lu",			    vbd_size(&be->blkif->vbd));	if (err) {		xenbus_dev_fatal(dev, err, "writing %s/sectors",				 dev->nodename);		goto abort;	}	/* FIXME: use a typename instead */	err = xenbus_printf(xbt, dev->nodename, "info", "%u",			    vbd_info(&be->blkif->vbd));	if (err) {		xenbus_dev_fatal(dev, err, "writing %s/info",				 dev->nodename);		goto abort;	}	err = xenbus_printf(xbt, dev->nodename, "sector-size", "%lu",			    vbd_secsize(&be->blkif->vbd));	if (err) {		xenbus_dev_fatal(dev, err, "writing %s/sector-size",				 dev->nodename);		goto abort;	}	err = xenbus_transaction_end(xbt, 0);	if (err == -EAGAIN)		goto again;	if (err)		xenbus_dev_fatal(dev, err, "ending transaction");	err = xenbus_switch_state(dev, XenbusStateConnected);	if (err)		xenbus_dev_fatal(dev, err, "switching to Connected state",				 dev->nodename);	return; abort:	xenbus_transaction_end(xbt, 1);}

static int publish_frontend_name(struct xenbus_device *dev){	struct xenbus_transaction tr;	int err;		/* Publish the name of the frontend driver */	do {		err = xenbus_transaction_start(&tr);		if (err != 0) { 			EPRINTK("%s: transaction start failed/n", __FUNCTION__);			return err;		}		err = xenbus_printf(tr, dev->nodename, "accel-frontend", 				    "%s", frontend_name);		if (err != 0) {			EPRINTK("%s: xenbus_printf failed/n", __FUNCTION__);			xenbus_transaction_end(tr, 1);			return err;		}		err = xenbus_transaction_end(tr, 0);	} while (err == -EAGAIN);		if (err != 0) {		EPRINTK("failed to end frontend name transaction/n");		return err;	}	return 0;}

static intxpv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd){	if (cmd != DDI_ATTACH)		return (DDI_FAILURE);	if (ddi_create_minor_node(dip, ddi_get_name(dip), S_IFCHR,	    ddi_get_instance(dip), DDI_PSEUDO, 0) != DDI_SUCCESS)		return (DDI_FAILURE);	xpv_dip = dip;	if (xpv_drv_init() != 0)		return (DDI_FAILURE);	ddi_report_dev(dip);	/*	 * If the memscrubber attempts to scrub the pages we hand to Xen,	 * the domain will panic.	 */	memscrub_disable();	/*	 * Report our version to dom0.	 */	if (xenbus_printf(XBT_NULL, "guest/xpv", "version", "%d",	    HVMPV_XPV_VERS))		cmn_err(CE_WARN, "xpv: couldn't write version/n");	return (DDI_SUCCESS);}

static void sysrq_handler(struct xenbus_watch *watch, const char *path,			  const char *token){	char sysrq_key = '/0';	struct xenbus_transaction xbt;	int err; again:	err = xenbus_transaction_start(&xbt);	if (err)		return;	err = xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key);	if (err < 0) {		/*		 * The Xenstore watch fires directly after registering it and		 * after a suspend/resume cycle. So ENOENT is no error but		 * might happen in those cases.		 */		if (err != -ENOENT)			pr_err("Error %d reading sysrq code in control/sysrq/n",			       err);		xenbus_transaction_end(xbt, 1);		return;	}	if (sysrq_key != '/0')		xenbus_printf(xbt, "control", "sysrq", "%c", '/0');	err = xenbus_transaction_end(xbt, 0);	if (err == -EAGAIN)		goto again;	if (sysrq_key != '/0')		handle_sysrq(sysrq_key);}

static int setup_shutdown_watcher(void){	int err;	int idx;#define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-"))	char node[FEATURE_PATH_SIZE];	err = register_xenbus_watch(&shutdown_watch);	if (err) {		pr_err("Failed to set shutdown watcher/n");		return err;	}#ifdef CONFIG_MAGIC_SYSRQ	err = register_xenbus_watch(&sysrq_watch);	if (err) {		pr_err("Failed to set sysrq watcher/n");		return err;	}#endif	for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {		if (!shutdown_handlers[idx].flag)			continue;		snprintf(node, FEATURE_PATH_SIZE, "feature-%s",			 shutdown_handlers[idx].command);		xenbus_printf(XBT_NIL, "control", node, "%u", 1);	}	return 0;}

ULONGXenLowerInterfaceVersion(    PXEN_LOWER XenLower){    NTSTATUS status;    PCHAR vstr;    int version;	vstr = XenLowerReadXenstoreValue(XenLower->BackendPath, "version");    if (vstr == NULL)    {        TraceError((__FUNCTION__/            ": XenLowerReadXenstoreValue() failed to return the vusb version./n"));        return 0;    }    sscanf_s(vstr, "%d", &version);    XmFreeMemory(vstr);    // Need to now write the version we support to the frontend    status = xenbus_printf(XBT_NIL, XenLower->FrontendPath,        "version", "%d", XEN_LOWER_INTERFACE_VERSION);    if (!NT_SUCCESS(status))    {        TraceError((__FUNCTION__/            ": xenbus_printf(frontend/version) failed./n"));        return 0;    }    TraceInfo((__FUNCTION__        ": Read backend version: %d  -  Wrote frontend version: %d/n",        version, XEN_LOWER_INTERFACE_VERSION));    return (ULONG)version;}

static void xenkbd_backend_changed(struct xenbus_device *dev,				   enum xenbus_state backend_state){	struct xenkbd_info *info = dev_get_drvdata(&dev->dev);	int ret, val;	switch (backend_state) {	case XenbusStateInitialising:	case XenbusStateInitialised:	case XenbusStateReconfiguring:	case XenbusStateReconfigured:	case XenbusStateUnknown:		break;	case XenbusStateInitWait:InitWait:		ret = xenbus_scanf(XBT_NIL, info->xbdev->otherend,				   "feature-abs-pointer", "%d", &val);		if (ret < 0)			val = 0;		if (val) {			ret = xenbus_printf(XBT_NIL, info->xbdev->nodename,					    "request-abs-pointer", "1");			if (ret)				pr_warning("xenkbd: can't request abs-pointer");		}		xenbus_switch_state(dev, XenbusStateConnected);		break;	case XenbusStateConnected:		/*		 * Work around xenbus race condition: If backend goes		 * through InitWait to Connected fast enough, we can		 * get Connected twice here.		 */		if (dev->state != XenbusStateConnected)			goto InitWait; /* no InitWait seen yet, fudge it */		/* Set input abs params to match backend screen res */		if (xenbus_scanf(XBT_NIL, info->xbdev->otherend,				 "width", "%d", &val) > 0)			input_set_abs_params(info->ptr, ABS_X, 0, val, 0, 0);		if (xenbus_scanf(XBT_NIL, info->xbdev->otherend,				 "height", "%d", &val) > 0)			input_set_abs_params(info->ptr, ABS_Y, 0, val, 0, 0);		break;	case XenbusStateClosed:		if (dev->state == XenbusStateClosed)			break;		/* Missed the backend's CLOSING state -- fallthrough */	case XenbusStateClosing:		xenbus_frontend_closed(dev);		break;	}}

/** * Entry point to this code when a new device is created.  Allocate the basic * structures, and watch the store waiting for the hotplug scripts to tell us * the device's handle.  Switch to InitWait. */static int netback_probe(struct xenbus_device *dev,			 const struct xenbus_device_id *id){	const char *message;	xenbus_transaction_t xbt;	int err;	struct backend_info *be = kzalloc(sizeof(struct backend_info),					  GFP_KERNEL);	if (!be) {		xenbus_dev_fatal(dev, -ENOMEM,				 "allocating backend structure");		return -ENOMEM;	}	be->dev = dev;	dev->data = be;	err = xenbus_watch_path2(dev, dev->nodename, "handle",				 &be->backend_watch, backend_changed);	if (err)		goto fail;	do {		err = xenbus_transaction_start(&xbt);		if (err) {			xenbus_dev_fatal(dev, err, "starting transaction");			goto fail;		}		err = xenbus_printf(xbt, dev->nodename, "feature-sg", "%d", 1);		if (err) {			message = "writing feature-sg";			goto abort_transaction;		}		err = xenbus_transaction_end(xbt, 0);	} while (err == -EAGAIN);	if (err) {		xenbus_dev_fatal(dev, err, "completing transaction");		goto fail;	}	err = xenbus_switch_state(dev, XenbusStateInitWait);	if (err) {		goto fail;	}	return 0;abort_transaction:	xenbus_transaction_end(xbt, 1);	xenbus_dev_fatal(dev, err, "%s", message);fail:	DPRINTK("failed");	netback_remove(dev);	return err;}

static int publish_xenbus(struct tpmfront_dev* dev) {   xenbus_transaction_t xbt;   int retry;   char* err;   /* Write the grant reference and event channel to xenstore */again:   if((err = xenbus_transaction_start(&xbt))) {      TPMFRONT_ERR("Unable to start xenbus transaction, error was %s/n", err);      free(err);      return -1;   }   if((err = xenbus_printf(xbt, dev->nodename, "ring-ref", "%u", (unsigned int) dev->ring_ref))) {      TPMFRONT_ERR("Unable to write %s/ring-ref, error was %s/n", dev->nodename, err);      free(err);      goto abort_transaction;   }   if((err = xenbus_printf(xbt, dev->nodename, "event-channel", "%u", (unsigned int) dev->evtchn))) {      TPMFRONT_ERR("Unable to write %s/event-channel, error was %s/n", dev->nodename, err);      free(err);      goto abort_transaction;   }   if((err = xenbus_transaction_end(xbt, 0, &retry))) {      TPMFRONT_ERR("Unable to complete xenbus transaction, error was %s/n", err);      free(err);      return -1;   }   if(retry) {      goto again;   }   return 0;abort_transaction:   if((err = xenbus_transaction_end(xbt, 1, &retry))) {      free(err);   }   return -1;}

static ULONGBalloonGetTopPage(    VOID    ){    PHYSICAL_MEMORY_RANGE   *Range;    PHYSICAL_ADDRESS        TopAddress;    ULONG                   Index;    Range = MmGetPhysicalMemoryRanges();    TopAddress.QuadPart = 0ull;    for (Index = 0; Range[Index].BaseAddress.QuadPart != 0 || Range[Index].NumberOfBytes.QuadPart != 0; Index++) {        PHYSICAL_ADDRESS EndAddress;        CHAR Key[32];        EndAddress.QuadPart = Range[Index].BaseAddress.QuadPart + Range[Index].NumberOfBytes.QuadPart;        TraceInfo(("PHYSICAL MEMORY: RANGE[%u] %08x.%08x - %08x.%08x/n",                   Index, Range[Index].BaseAddress.HighPart, Range[Index].BaseAddress.LowPart,                   EndAddress.HighPart, EndAddress.LowPart));        (VOID) Xmsnprintf(Key, sizeof (Key), "data/physical-memory/range%u", Index);        (VOID) xenbus_printf(XBT_NIL, Key, "base", "%08x.%08x",                              Range[Index].BaseAddress.HighPart,                             Range[Index].BaseAddress.LowPart);        (VOID) xenbus_printf(XBT_NIL, Key, "end", "%08x.%08x",                             EndAddress.HighPart,                             EndAddress.LowPart);        if (EndAddress.QuadPart > TopAddress.QuadPart)            TopAddress.QuadPart = EndAddress.QuadPart;    }    TraceNotice(("PHYSICAL MEMORY: TOP = %08x.%08x/n", TopAddress.HighPart, TopAddress.LowPart));    return (ULONG)(TopAddress.QuadPart >> PAGE_SHIFT);}

static void xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_info *be){	struct xenbus_device *dev = be->dev;	struct xen_blkif *blkif = be->blkif;	int err;	int state = 0;	struct block_device *bdev = be->blkif->vbd.bdev;	struct request_queue *q = bdev_get_queue(bdev);	if (blk_queue_discard(q)) {		err = xenbus_printf(xbt, dev->nodename,			"discard-granularity", "%u",			q->limits.discard_granularity);		if (err) {			dev_warn(&dev->dev, "writing discard-granularity (%d)", err);			return;		}		err = xenbus_printf(xbt, dev->nodename,			"discard-alignment", "%u",			q->limits.discard_alignment);		if (err) {			dev_warn(&dev->dev, "writing discard-alignment (%d)", err);			return;		}		state = 1;		/* Optional. */		err = xenbus_printf(xbt, dev->nodename,				    "discard-secure", "%d",				    blkif->vbd.discard_secure);		if (err) {			dev_warn(&dev->dev, "writing discard-secure (%d)", err);			return;		}	}	err = xenbus_printf(xbt, dev->nodename, "feature-discard",			    "%d", state);	if (err)		dev_warn(&dev->dev, "writing feature-discard (%d)", err);}

int xen_blkbk_barrier(struct xenbus_transaction xbt,		      struct backend_info *be, int state){	struct xenbus_device *dev = be->dev;	int err;	err = xenbus_printf(xbt, dev->nodename, "feature-barrier",			    "%d", state);	if (err)		dev_warn(&dev->dev, "writing feature-barrier (%d)", err);	return err;}

int xen_blkbk_flush_diskcache(struct xenbus_transaction xbt,			      struct backend_info *be, int state){	struct xenbus_device *dev = be->dev;	int err;	err = xenbus_printf(xbt, dev->nodename, "feature-flush-cache",			    "%d", state);	if (err)		xenbus_dev_fatal(dev, err, "writing feature-flush-cache");	return err;}