[S390] cio: introduce parent-initiated device move (5d6e6b6f) · Commits · 戴 / test

drivers/s390/cio/css.c

+7 −2

Original line number	Diff line number	Diff line
		@@ -376,8 +376,8 @@ static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
		/* Unusable - ignore. */
		return 0;
		}
		CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, unknown, "
		"slow path.\n", schid.ssid, schid.sch_no, CIO_OPER);
		CIO_MSG_EVENT(4, "event: sch 0.%x.%04x, new\n", schid.ssid,
		schid.sch_no);

		return css_probe_device(schid);
		}
		@@ -394,6 +394,10 @@ static int css_evaluate_known_subchannel(struct subchannel *sch, int slow)
		"Got subchannel machine check but "
		"no sch_event handler provided.\n");
		}
		if (ret != 0 && ret != -EAGAIN) {
		CIO_MSG_EVENT(2, "eval: sch 0.%x.%04x, rc=%d\n",
		sch->schid.ssid, sch->schid.sch_no, ret);
		}
		return ret;
		}

		@@ -684,6 +688,7 @@ static int __init setup_css(int nr)
		css->pseudo_subchannel->dev.parent = &css->device;
		css->pseudo_subchannel->dev.release = css_subchannel_release;
		dev_set_name(&css->pseudo_subchannel->dev, "defunct");
		mutex_init(&css->pseudo_subchannel->reg_mutex);
		ret = cio_create_sch_lock(css->pseudo_subchannel);
		if (ret) {
		kfree(css->pseudo_subchannel);

drivers/s390/cio/device.c

+182 −331

Original line number	Diff line number	Diff line
		@@ -673,57 +673,19 @@ static int ccw_device_register(struct ccw_device *cdev)
		return ret;
		}

		struct match_data {
		struct ccw_dev_id dev_id;
		struct ccw_device * sibling;
		};

		static int
		match_devno(struct device * dev, void * data)
		{
		struct match_data * d = data;
		struct ccw_device * cdev;

		cdev = to_ccwdev(dev);
		if ((cdev->private->state == DEV_STATE_DISCONNECTED) &&
		!ccw_device_is_orphan(cdev) &&
		ccw_dev_id_is_equal(&cdev->private->dev_id, &d->dev_id) &&
		(cdev != d->sibling))
		return 1;
		return 0;
		}

		static struct ccw_device * get_disc_ccwdev_by_dev_id(struct ccw_dev_id *dev_id,
		struct ccw_device *sibling)
		{
		struct device *dev;
		struct match_data data;

		data.dev_id = *dev_id;
		data.sibling = sibling;
		dev = bus_find_device(&ccw_bus_type, NULL, &data, match_devno);

		return dev ? to_ccwdev(dev) : NULL;
		}

		static int match_orphan(struct device dev, void data)
		static int match_dev_id(struct device dev, void data)
		{
		struct ccw_dev_id *dev_id;
		struct ccw_device *cdev;
		struct ccw_device *cdev = to_ccwdev(dev);
		struct ccw_dev_id *dev_id = data;

		dev_id = data;
		cdev = to_ccwdev(dev);
		return ccw_dev_id_is_equal(&cdev->private->dev_id, dev_id);
		}

		static struct ccw_device *
		get_orphaned_ccwdev_by_dev_id(struct channel_subsystem *css,
		struct ccw_dev_id *dev_id)
		static struct ccw_device get_ccwdev_by_dev_id(struct ccw_dev_id dev_id)
		{
		struct device *dev;

		dev = device_find_child(&css->pseudo_subchannel->dev, dev_id,
		match_orphan);
		dev = bus_find_device(&ccw_bus_type, NULL, dev_id, match_dev_id);

		return dev ? to_ccwdev(dev) : NULL;
		}
		@@ -808,75 +770,6 @@ static struct ccw_device * io_subchannel_create_ccwdev(struct subchannel *sch)

		static int io_subchannel_recog(struct ccw_device , struct subchannel );

		static void sch_attach_device(struct subchannel *sch,
		struct ccw_device *cdev)
		{
		css_update_ssd_info(sch);
		spin_lock_irq(sch->lock);
		sch_set_cdev(sch, cdev);
		cdev->private->schid = sch->schid;
		cdev->ccwlock = sch->lock;
		ccw_device_trigger_reprobe(cdev);
		spin_unlock_irq(sch->lock);
		}

		static void sch_attach_disconnected_device(struct subchannel *sch,
		struct ccw_device *cdev)
		{
		struct subchannel *other_sch;
		int ret;

		/* Get reference for new parent. */
		if (!get_device(&sch->dev))
		return;
		other_sch = to_subchannel(cdev->dev.parent);
		/* Note: device_move() changes cdev->dev.parent */
		ret = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
		if (ret) {
		CIO_MSG_EVENT(0, "Moving disconnected device 0.%x.%04x failed "
		"(ret=%d)!\n", cdev->private->dev_id.ssid,
		cdev->private->dev_id.devno, ret);
		/* Put reference for new parent. */
		put_device(&sch->dev);
		return;
		}
		sch_set_cdev(other_sch, NULL);
		/* No need to keep a subchannel without ccw device around. */
		css_sch_device_unregister(other_sch);
		sch_attach_device(sch, cdev);
		/* Put reference for old parent. */
		put_device(&other_sch->dev);
		}

		static void sch_attach_orphaned_device(struct subchannel *sch,
		struct ccw_device *cdev)
		{
		int ret;
		struct subchannel *pseudo_sch;

		/* Get reference for new parent. */
		if (!get_device(&sch->dev))
		return;
		pseudo_sch = to_subchannel(cdev->dev.parent);
		/*
		* Try to move the ccw device to its new subchannel.
		* Note: device_move() changes cdev->dev.parent
		*/
		ret = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
		if (ret) {
		CIO_MSG_EVENT(0, "Moving device 0.%x.%04x from orphanage "
		"failed (ret=%d)!\n",
		cdev->private->dev_id.ssid,
		cdev->private->dev_id.devno, ret);
		/* Put reference for new parent. */
		put_device(&sch->dev);
		return;
		}
		sch_attach_device(sch, cdev);
		/* Put reference on pseudo subchannel. */
		put_device(&pseudo_sch->dev);
		}

		static void sch_create_and_recog_new_device(struct subchannel *sch)
		{
		struct ccw_device *cdev;
		@@ -901,70 +794,6 @@ static void sch_create_and_recog_new_device(struct subchannel *sch)
		}
		}


		void ccw_device_move_to_orphanage(struct work_struct *work)
		{
		struct ccw_device_private *priv;
		struct ccw_device *cdev;
		struct ccw_device *replacing_cdev;
		struct subchannel *sch;
		int ret;
		struct channel_subsystem *css;
		struct ccw_dev_id dev_id;

		priv = container_of(work, struct ccw_device_private, kick_work);
		cdev = priv->cdev;
		sch = to_subchannel(cdev->dev.parent);
		css = to_css(sch->dev.parent);
		dev_id.devno = sch->schib.pmcw.dev;
		dev_id.ssid = sch->schid.ssid;

		/* Increase refcount for pseudo subchannel. */
		get_device(&css->pseudo_subchannel->dev);
		/*
		* Move the orphaned ccw device to the orphanage so the replacing
		* ccw device can take its place on the subchannel.
		* Note: device_move() changes cdev->dev.parent
		*/
		ret = device_move(&cdev->dev, &css->pseudo_subchannel->dev,
		DPM_ORDER_NONE);
		if (ret) {
		CIO_MSG_EVENT(0, "Moving device 0.%x.%04x to orphanage failed "
		"(ret=%d)!\n", cdev->private->dev_id.ssid,
		cdev->private->dev_id.devno, ret);
		/* Decrease refcount for pseudo subchannel again. */
		put_device(&css->pseudo_subchannel->dev);
		return;
		}
		cdev->ccwlock = css->pseudo_subchannel->lock;
		/*
		* Search for the replacing ccw device
		* - among the disconnected devices
		* - in the orphanage
		*/
		replacing_cdev = get_disc_ccwdev_by_dev_id(&dev_id, cdev);
		if (replacing_cdev) {
		sch_attach_disconnected_device(sch, replacing_cdev);
		/* Release reference from get_disc_ccwdev_by_dev_id() */
		put_device(&replacing_cdev->dev);
		/* Release reference of subchannel from old cdev. */
		put_device(&sch->dev);
		return;
		}
		replacing_cdev = get_orphaned_ccwdev_by_dev_id(css, &dev_id);
		if (replacing_cdev) {
		sch_attach_orphaned_device(sch, replacing_cdev);
		/* Release reference from get_orphaned_ccwdev_by_dev_id() */
		put_device(&replacing_cdev->dev);
		/* Release reference of subchannel from old cdev. */
		put_device(&sch->dev);
		return;
		}
		sch_create_and_recog_new_device(sch);
		/* Release reference of subchannel from old cdev. */
		put_device(&sch->dev);
		}

		/*
		* Register recognized device.
		*/
		@@ -1131,53 +960,56 @@ io_subchannel_recog(struct ccw_device cdev, struct subchannel sch)
		return rc;
		}

		static void ccw_device_move_to_sch(struct work_struct *work)
		static int ccw_device_move_to_sch(struct ccw_device *cdev,
		struct subchannel *sch)
		{
		struct ccw_device_private *priv;
		struct subchannel *old_sch;
		int rc;
		struct subchannel *sch;
		struct ccw_device *cdev;
		struct subchannel *former_parent;

		priv = container_of(work, struct ccw_device_private, kick_work);
		sch = priv->sch;
		cdev = priv->cdev;
		former_parent = to_subchannel(cdev->dev.parent);
		/* Get reference for new parent. */
		old_sch = to_subchannel(cdev->dev.parent);
		/* Obtain child reference for new parent. */
		if (!get_device(&sch->dev))
		return;
		return -ENODEV;
		mutex_lock(&sch->reg_mutex);
		/*
		* Try to move the ccw device to its new subchannel.
		* Note: device_move() changes cdev->dev.parent
		*/
		rc = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
		mutex_unlock(&sch->reg_mutex);
		if (rc) {
		CIO_MSG_EVENT(0, "Moving device 0.%x.%04x to subchannel "
		"0.%x.%04x failed (ret=%d)!\n",
		CIO_MSG_EVENT(0, "device_move(0.%x.%04x,0.%x.%04x)=%d\n",
		cdev->private->dev_id.ssid,
		cdev->private->dev_id.devno, sch->schid.ssid,
		sch->schid.sch_no, rc);
		css_sch_device_unregister(sch);
		/* Put reference for new parent again. */
		sch->schib.pmcw.dev, rc);
		/* Release child reference for new parent. */
		put_device(&sch->dev);
		goto out;
		return rc;
		}
		if (!sch_is_pseudo_sch(former_parent)) {
		spin_lock_irq(former_parent->lock);
		sch_set_cdev(former_parent, NULL);
		spin_unlock_irq(former_parent->lock);
		css_sch_device_unregister(former_parent);
		/* Reset intparm to zeroes. */
		former_parent->config.intparm = 0;
		cio_commit_config(former_parent);
		/* Clean up old subchannel. */
		if (!sch_is_pseudo_sch(old_sch)) {
		spin_lock_irq(old_sch->lock);
		sch_set_cdev(old_sch, NULL);
		cio_disable_subchannel(old_sch);
		spin_unlock_irq(old_sch->lock);
		css_schedule_eval(old_sch->schid);
		}
		/* Release child reference for old parent. */
		put_device(&old_sch->dev);
		/* Initialize new subchannel. */
		spin_lock_irq(sch->lock);
		cdev->private->schid = sch->schid;
		cdev->ccwlock = sch->lock;
		if (!sch_is_pseudo_sch(sch))
		sch_set_cdev(sch, cdev);
		spin_unlock_irq(sch->lock);
		if (!sch_is_pseudo_sch(sch))
		css_update_ssd_info(sch);
		return 0;
		}
		sch_attach_device(sch, cdev);
		out:
		/* Put reference for old parent. */
		put_device(&former_parent->dev);
		put_device(&cdev->dev);

		static int ccw_device_move_to_orph(struct ccw_device *cdev)
		{
		struct subchannel *sch = to_subchannel(cdev->dev.parent);
		struct channel_subsystem *css = to_css(sch->dev.parent);

		return ccw_device_move_to_sch(cdev, css->pseudo_subchannel);
		}

		static void io_subchannel_irq(struct subchannel *sch)
		@@ -1244,8 +1076,6 @@ static int io_subchannel_probe(struct subchannel *sch)
		{
		struct ccw_device *cdev;
		int rc;
		unsigned long flags;
		struct ccw_dev_id dev_id;

		if (cio_is_console(sch->schid)) {
		rc = sysfs_create_group(&sch->dev.kobj,
		@@ -1290,37 +1120,7 @@ static int io_subchannel_probe(struct subchannel *sch)
		GFP_KERNEL \| GFP_DMA);
		if (!sch->private)
		goto out_schedule;
		/*
		* First check if a fitting device may be found amongst the
		* disconnected devices or in the orphanage.
		*/
		dev_id.devno = sch->schib.pmcw.dev;
		dev_id.ssid = sch->schid.ssid;
		cdev = get_disc_ccwdev_by_dev_id(&dev_id, NULL);
		if (!cdev)
		cdev = get_orphaned_ccwdev_by_dev_id(to_css(sch->dev.parent),
		&dev_id);
		if (cdev) {
		/*
		* Schedule moving the device until when we have a registered
		* subchannel to move to and succeed the probe. We can
		* unregister later again, when the probe is through.
		*/
		cdev->private->sch = sch;
		PREPARE_WORK(&cdev->private->kick_work,
		ccw_device_move_to_sch);
		queue_work(slow_path_wq, &cdev->private->kick_work);
		return 0;
		}
		cdev = io_subchannel_create_ccwdev(sch);
		if (IS_ERR(cdev))
		goto out_schedule;
		rc = io_subchannel_recog(cdev, sch);
		if (rc) {
		spin_lock_irqsave(sch->lock, flags);
		io_subchannel_recog_done(cdev);
		spin_unlock_irqrestore(sch->lock, flags);
		}
		css_schedule_eval(sch->schid);
		return 0;

		out_schedule:
		@@ -1349,16 +1149,6 @@ out_free:
		return 0;
		}

		static int io_subchannel_notify(struct subchannel *sch, int event)
		{
		struct ccw_device *cdev;

		cdev = sch_get_cdev(sch);
		if (!cdev)
		return 0;
		return ccw_device_notify(cdev, event);
		}

		static void io_subchannel_verify(struct subchannel *sch)
		{
		struct ccw_device *cdev;
		@@ -1482,19 +1272,6 @@ io_subchannel_shutdown(struct subchannel *sch)
		cio_disable_subchannel(sch);
		}

		static int io_subchannel_get_status(struct subchannel *sch)
		{
		struct schib schib;

		if (stsch(sch->schid, &schib) \|\| !schib.pmcw.dnv)
		return CIO_GONE;
		if (sch->schib.pmcw.dnv && (schib.pmcw.dev != sch->schib.pmcw.dev))
		return CIO_REVALIDATE;
		if (!sch->lpm)
		return CIO_NO_PATH;
		return CIO_OPER;
		}

		static int device_is_disconnected(struct ccw_device *cdev)
		{
		if (!cdev)
		@@ -1626,91 +1403,165 @@ void ccw_device_set_notoper(struct ccw_device *cdev)
		cdev->private->state = DEV_STATE_NOT_OPER;
		}

		static int io_subchannel_sch_event(struct subchannel *sch, int slow)
		enum io_sch_action {
		IO_SCH_UNREG,
		IO_SCH_ORPH_UNREG,
		IO_SCH_ATTACH,
		IO_SCH_UNREG_ATTACH,
		IO_SCH_ORPH_ATTACH,
		IO_SCH_REPROBE,
		IO_SCH_VERIFY,
		IO_SCH_DISC,
		IO_SCH_NOP,
		};

		static enum io_sch_action sch_get_action(struct subchannel *sch)
		{
		struct ccw_device *cdev;

		cdev = sch_get_cdev(sch);
		if (cio_update_schib(sch)) {
		/* Not operational. */
		if (!cdev)
		return IO_SCH_UNREG;
		if (!ccw_device_notify(cdev, CIO_GONE))
		return IO_SCH_UNREG;
		return IO_SCH_ORPH_UNREG;
		}
		/* Operational. */
		if (!cdev)
		return IO_SCH_ATTACH;
		if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
		if (!ccw_device_notify(cdev, CIO_GONE))
		return IO_SCH_UNREG_ATTACH;
		return IO_SCH_ORPH_ATTACH;
		}
		if ((sch->schib.pmcw.pam & sch->opm) == 0) {
		if (!ccw_device_notify(cdev, CIO_NO_PATH))
		return IO_SCH_UNREG;
		return IO_SCH_DISC;
		}
		if (device_is_disconnected(cdev))
		return IO_SCH_REPROBE;
		if (cdev->online)
		return IO_SCH_VERIFY;
		return IO_SCH_NOP;
		}

		/**
		* io_subchannel_sch_event - process subchannel event
		* @sch: subchannel
		* @process: non-zero if function is called in process context
		*
		* An unspecified event occurred for this subchannel. Adjust data according
		* to the current operational state of the subchannel and device. Return
		* zero when the event has been handled sufficiently or -EAGAIN when this
		* function should be called again in process context.
		*/
		static int io_subchannel_sch_event(struct subchannel *sch, int process)
		{
		int event, ret, disc;
		unsigned long flags;
		enum { NONE, UNREGISTER, UNREGISTER_PROBE, REPROBE, DISC } action;
		struct ccw_device *cdev;
		struct ccw_dev_id dev_id;
		enum io_sch_action action;
		int rc = -EAGAIN;

		spin_lock_irqsave(sch->lock, flags);
		if (!device_is_registered(&sch->dev))
		goto out_unlock;
		action = sch_get_action(sch);
		CIO_MSG_EVENT(2, "event: sch 0.%x.%04x, process=%d, action=%d\n",
		sch->schid.ssid, sch->schid.sch_no, process,
		action);
		/* Perform immediate actions while holding the lock. */
		cdev = sch_get_cdev(sch);
		disc = device_is_disconnected(cdev);
		if (disc && slow) {
		/* Disconnected devices are evaluated directly only.*/
		spin_unlock_irqrestore(sch->lock, flags);
		return 0;
		}
		/* No interrupt after machine check - kill pending timers. */
		switch (action) {
		case IO_SCH_REPROBE:
		/* Trigger device recognition. */
		ccw_device_trigger_reprobe(cdev);
		rc = 0;
		goto out_unlock;
		case IO_SCH_VERIFY:
		/* Trigger path verification. */
		io_subchannel_verify(sch);
		rc = 0;
		goto out_unlock;
		case IO_SCH_DISC:
		ccw_device_set_disconnected(cdev);
		rc = 0;
		goto out_unlock;
		case IO_SCH_ORPH_UNREG:
		case IO_SCH_ORPH_ATTACH:
		ccw_device_set_disconnected(cdev);
		break;
		case IO_SCH_UNREG_ATTACH:
		case IO_SCH_UNREG:
		if (cdev)
		ccw_device_set_timeout(cdev, 0);
		if (!disc && !slow) {
		/* Non-disconnected devices are evaluated on the slow path. */
		spin_unlock_irqrestore(sch->lock, flags);
		return -EAGAIN;
		}
		event = io_subchannel_get_status(sch);
		CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, %s, %s path.\n",
		sch->schid.ssid, sch->schid.sch_no, event,
		disc ? "disconnected" : "normal",
		slow ? "slow" : "fast");
		/* Analyze subchannel status. */
		action = NONE;
		switch (event) {
		case CIO_NO_PATH:
		if (disc) {
		/* Check if paths have become available. */
		action = REPROBE;
		ccw_device_set_notoper(cdev);
		break;
		case IO_SCH_NOP:
		rc = 0;
		goto out_unlock;
		default:
		break;
		}
		/* fall through */
		case CIO_GONE:
		/* Ask driver what to do with device. */
		if (io_subchannel_notify(sch, event))
		action = DISC;
		else
		action = UNREGISTER;
		spin_unlock_irqrestore(sch->lock, flags);
		/* All other actions require process context. */
		if (!process)
		goto out;
		/* Handle attached ccw device. */
		switch (action) {
		case IO_SCH_ORPH_UNREG:
		case IO_SCH_ORPH_ATTACH:
		/* Move ccw device to orphanage. */
		rc = ccw_device_move_to_orph(cdev);
		if (rc)
		goto out;
		break;
		case CIO_REVALIDATE:
		/* Device will be removed, so no notify necessary. */
		if (disc)
		/* Reprobe because immediate unregister might block. */
		action = REPROBE;
		else
		action = UNREGISTER_PROBE;
		case IO_SCH_UNREG_ATTACH:
		/* Unregister ccw device. */
		ccw_device_unregister(cdev);
		break;
		case CIO_OPER:
		if (disc)
		/* Get device operational again. */
		action = REPROBE;
		default:
		break;
		}
		/* Perform action. */
		ret = 0;
		/* Handle subchannel. */
		switch (action) {
		case UNREGISTER:
		case UNREGISTER_PROBE:
		ccw_device_set_notoper(cdev);
		/* Unregister device (will use subchannel lock). */
		spin_unlock_irqrestore(sch->lock, flags);
		case IO_SCH_ORPH_UNREG:
		case IO_SCH_UNREG:
		css_sch_device_unregister(sch);
		spin_lock_irqsave(sch->lock, flags);
		break;
		case REPROBE:
		ccw_device_trigger_reprobe(cdev);
		case IO_SCH_ORPH_ATTACH:
		case IO_SCH_UNREG_ATTACH:
		case IO_SCH_ATTACH:
		dev_id.ssid = sch->schid.ssid;
		dev_id.devno = sch->schib.pmcw.dev;
		cdev = get_ccwdev_by_dev_id(&dev_id);
		if (!cdev) {
		sch_create_and_recog_new_device(sch);
		break;
		case DISC:
		ccw_device_set_disconnected(cdev);
		}
		rc = ccw_device_move_to_sch(cdev, sch);
		if (rc) {
		/* Release reference from get_ccwdev_by_dev_id() */
		put_device(&cdev->dev);
		goto out;
		}
		spin_lock_irqsave(sch->lock, flags);
		ccw_device_trigger_reprobe(cdev);
		spin_unlock_irqrestore(sch->lock, flags);
		/* Release reference from get_ccwdev_by_dev_id() */
		put_device(&cdev->dev);
		break;
		default:
		break;
		}
		spin_unlock_irqrestore(sch->lock, flags);
		/* Probe if necessary. */
		if (action == UNREGISTER_PROBE)
		ret = css_probe_device(sch->schid);
		return 0;

		return ret;
		out_unlock:
		spin_unlock_irqrestore(sch->lock, flags);
		out:
		return rc;
		}

		#ifdef CONFIG_CCW_CONSOLE

drivers/s390/cio/device_fsm.c

+3 −5

Original line number	Diff line number	Diff line
		@@ -1072,11 +1072,9 @@ void ccw_device_trigger_reprobe(struct ccw_device *cdev)

		/* We should also udate ssd info, but this has to wait. */
		/* Check if this is another device which appeared on the same sch. */
		if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
		PREPARE_WORK(&cdev->private->kick_work,
		ccw_device_move_to_orphanage);
		queue_work(slow_path_wq, &cdev->private->kick_work);
		} else
		if (sch->schib.pmcw.dev != cdev->private->dev_id.devno)
		css_schedule_eval(sch->schid);
		else
		ccw_device_start_id(cdev, 0);
		}

Admin message