mirror of
https://github.com/torvalds/linux.git
synced 2024-12-06 11:01:43 +00:00
ad9a145172
Since commit48720ba568
("virtio/s390: use DMA memory for ccw I/O and classic notifiers") we were supposed to make sure that virtio_ccw_release_dev() completes before the ccw device and the attached dma pool are torn down, but unfortunately we did not. Before that commit it used to be OK to delay cleaning up the memory allocated by virtio-ccw indefinitely (which isn't really intuitive for guys used to destruction happens in reverse construction order), but now we trigger a BUG_ON if the genpool is destroyed before all memory allocated from it is deallocated. Which brings down the guest. We can observe this problem, when unregister_virtio_device() does not give up the last reference to the virtio_device (e.g. because a virtio-scsi attached scsi disk got removed without previously unmounting its previously mounted partition). To make sure that the genpool is only destroyed after all the necessary freeing is done let us take a reference on the ccw device on each ccw_device_dma_zalloc() and give it up on each ccw_device_dma_free(). Actually there are multiple approaches to fixing the problem at hand that can work. The upside of this one is that it is the safest one while remaining simple. We don't crash the guest even if the driver does not pair allocations and frees. The downside is the reference counting overhead, that the reference counting for ccw devices becomes more complex, in a sense that we need to pair the calls to the aforementioned functions for it to be correct, and that if we happen to leak, we leak more than necessary (the whole ccw device instead of just the genpool). Some alternatives to this approach are taking a reference in virtio_ccw_online() and giving it up in virtio_ccw_release_dev() or making sure virtio_ccw_release_dev() completes its work before virtio_ccw_remove() returns. The downside of these approaches is that these are less safe against programming errors. Cc: <stable@vger.kernel.org> # v5.3 Signed-off-by: Halil Pasic <pasic@linux.ibm.com> Fixes:48720ba568
("virtio/s390: use DMA memory for ccw I/O and classic notifiers") Reported-by: bfu@redhat.com Reviewed-by: Vineeth Vijayan <vneethv@linux.ibm.com> Acked-by: Cornelia Huck <cohuck@redhat.com> Signed-off-by: Vasily Gorbik <gor@linux.ibm.com>
862 lines
27 KiB
C
862 lines
27 KiB
C
// SPDX-License-Identifier: GPL-1.0+
|
|
/*
|
|
* Copyright IBM Corp. 2002, 2009
|
|
*
|
|
* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
|
|
* Cornelia Huck (cornelia.huck@de.ibm.com)
|
|
*/
|
|
#include <linux/export.h>
|
|
#include <linux/init.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/list.h>
|
|
#include <linux/device.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/completion.h>
|
|
|
|
#include <asm/ccwdev.h>
|
|
#include <asm/idals.h>
|
|
#include <asm/chpid.h>
|
|
#include <asm/fcx.h>
|
|
|
|
#include "cio.h"
|
|
#include "cio_debug.h"
|
|
#include "css.h"
|
|
#include "chsc.h"
|
|
#include "device.h"
|
|
#include "chp.h"
|
|
|
|
/**
|
|
* ccw_device_set_options_mask() - set some options and unset the rest
|
|
* @cdev: device for which the options are to be set
|
|
* @flags: options to be set
|
|
*
|
|
* All flags specified in @flags are set, all flags not specified in @flags
|
|
* are cleared.
|
|
* Returns:
|
|
* %0 on success, -%EINVAL on an invalid flag combination.
|
|
*/
|
|
int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
|
|
{
|
|
/*
|
|
* The flag usage is mutal exclusive ...
|
|
*/
|
|
if ((flags & CCWDEV_EARLY_NOTIFICATION) &&
|
|
(flags & CCWDEV_REPORT_ALL))
|
|
return -EINVAL;
|
|
cdev->private->options.fast = (flags & CCWDEV_EARLY_NOTIFICATION) != 0;
|
|
cdev->private->options.repall = (flags & CCWDEV_REPORT_ALL) != 0;
|
|
cdev->private->options.pgroup = (flags & CCWDEV_DO_PATHGROUP) != 0;
|
|
cdev->private->options.force = (flags & CCWDEV_ALLOW_FORCE) != 0;
|
|
cdev->private->options.mpath = (flags & CCWDEV_DO_MULTIPATH) != 0;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ccw_device_set_options() - set some options
|
|
* @cdev: device for which the options are to be set
|
|
* @flags: options to be set
|
|
*
|
|
* All flags specified in @flags are set, the remainder is left untouched.
|
|
* Returns:
|
|
* %0 on success, -%EINVAL if an invalid flag combination would ensue.
|
|
*/
|
|
int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
|
|
{
|
|
/*
|
|
* The flag usage is mutal exclusive ...
|
|
*/
|
|
if (((flags & CCWDEV_EARLY_NOTIFICATION) &&
|
|
(flags & CCWDEV_REPORT_ALL)) ||
|
|
((flags & CCWDEV_EARLY_NOTIFICATION) &&
|
|
cdev->private->options.repall) ||
|
|
((flags & CCWDEV_REPORT_ALL) &&
|
|
cdev->private->options.fast))
|
|
return -EINVAL;
|
|
cdev->private->options.fast |= (flags & CCWDEV_EARLY_NOTIFICATION) != 0;
|
|
cdev->private->options.repall |= (flags & CCWDEV_REPORT_ALL) != 0;
|
|
cdev->private->options.pgroup |= (flags & CCWDEV_DO_PATHGROUP) != 0;
|
|
cdev->private->options.force |= (flags & CCWDEV_ALLOW_FORCE) != 0;
|
|
cdev->private->options.mpath |= (flags & CCWDEV_DO_MULTIPATH) != 0;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ccw_device_clear_options() - clear some options
|
|
* @cdev: device for which the options are to be cleared
|
|
* @flags: options to be cleared
|
|
*
|
|
* All flags specified in @flags are cleared, the remainder is left untouched.
|
|
*/
|
|
void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
|
|
{
|
|
cdev->private->options.fast &= (flags & CCWDEV_EARLY_NOTIFICATION) == 0;
|
|
cdev->private->options.repall &= (flags & CCWDEV_REPORT_ALL) == 0;
|
|
cdev->private->options.pgroup &= (flags & CCWDEV_DO_PATHGROUP) == 0;
|
|
cdev->private->options.force &= (flags & CCWDEV_ALLOW_FORCE) == 0;
|
|
cdev->private->options.mpath &= (flags & CCWDEV_DO_MULTIPATH) == 0;
|
|
}
|
|
|
|
/**
|
|
* ccw_device_is_pathgroup() - determine if paths to this device are grouped
|
|
* @cdev: ccw device
|
|
*
|
|
* Return non-zero if there is a path group, zero otherwise.
|
|
*/
|
|
int ccw_device_is_pathgroup(struct ccw_device *cdev)
|
|
{
|
|
return cdev->private->flags.pgroup;
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_is_pathgroup);
|
|
|
|
/**
|
|
* ccw_device_is_multipath() - determine if device is operating in multipath mode
|
|
* @cdev: ccw device
|
|
*
|
|
* Return non-zero if device is operating in multipath mode, zero otherwise.
|
|
*/
|
|
int ccw_device_is_multipath(struct ccw_device *cdev)
|
|
{
|
|
return cdev->private->flags.mpath;
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_is_multipath);
|
|
|
|
/**
|
|
* ccw_device_clear() - terminate I/O request processing
|
|
* @cdev: target ccw device
|
|
* @intparm: interruption parameter to be returned upon conclusion of csch
|
|
*
|
|
* ccw_device_clear() calls csch on @cdev's subchannel.
|
|
* Returns:
|
|
* %0 on success,
|
|
* -%ENODEV on device not operational,
|
|
* -%EINVAL on invalid device state.
|
|
* Context:
|
|
* Interrupts disabled, ccw device lock held
|
|
*/
|
|
int ccw_device_clear(struct ccw_device *cdev, unsigned long intparm)
|
|
{
|
|
struct subchannel *sch;
|
|
int ret;
|
|
|
|
if (!cdev || !cdev->dev.parent)
|
|
return -ENODEV;
|
|
sch = to_subchannel(cdev->dev.parent);
|
|
if (!sch->schib.pmcw.ena)
|
|
return -EINVAL;
|
|
if (cdev->private->state == DEV_STATE_NOT_OPER)
|
|
return -ENODEV;
|
|
if (cdev->private->state != DEV_STATE_ONLINE &&
|
|
cdev->private->state != DEV_STATE_W4SENSE)
|
|
return -EINVAL;
|
|
|
|
ret = cio_clear(sch);
|
|
if (ret == 0)
|
|
cdev->private->intparm = intparm;
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ccw_device_start_timeout_key() - start a s390 channel program with timeout and key
|
|
* @cdev: target ccw device
|
|
* @cpa: logical start address of channel program
|
|
* @intparm: user specific interruption parameter; will be presented back to
|
|
* @cdev's interrupt handler. Allows a device driver to associate
|
|
* the interrupt with a particular I/O request.
|
|
* @lpm: defines the channel path to be used for a specific I/O request. A
|
|
* value of 0 will make cio use the opm.
|
|
* @key: storage key to be used for the I/O
|
|
* @flags: additional flags; defines the action to be performed for I/O
|
|
* processing.
|
|
* @expires: timeout value in jiffies
|
|
*
|
|
* Start a S/390 channel program. When the interrupt arrives, the
|
|
* IRQ handler is called, either immediately, delayed (dev-end missing,
|
|
* or sense required) or never (no IRQ handler registered).
|
|
* This function notifies the device driver if the channel program has not
|
|
* completed during the time specified by @expires. If a timeout occurs, the
|
|
* channel program is terminated via xsch, hsch or csch, and the device's
|
|
* interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
|
|
* The interruption handler will echo back the @intparm specified here, unless
|
|
* another interruption parameter is specified by a subsequent invocation of
|
|
* ccw_device_halt() or ccw_device_clear().
|
|
* Returns:
|
|
* %0, if the operation was successful;
|
|
* -%EBUSY, if the device is busy, or status pending;
|
|
* -%EACCES, if no path specified in @lpm is operational;
|
|
* -%ENODEV, if the device is not operational.
|
|
* Context:
|
|
* Interrupts disabled, ccw device lock held
|
|
*/
|
|
int ccw_device_start_timeout_key(struct ccw_device *cdev, struct ccw1 *cpa,
|
|
unsigned long intparm, __u8 lpm, __u8 key,
|
|
unsigned long flags, int expires)
|
|
{
|
|
struct subchannel *sch;
|
|
int ret;
|
|
|
|
if (!cdev || !cdev->dev.parent)
|
|
return -ENODEV;
|
|
sch = to_subchannel(cdev->dev.parent);
|
|
if (!sch->schib.pmcw.ena)
|
|
return -EINVAL;
|
|
if (cdev->private->state == DEV_STATE_NOT_OPER)
|
|
return -ENODEV;
|
|
if (cdev->private->state == DEV_STATE_VERIFY) {
|
|
/* Remember to fake irb when finished. */
|
|
if (!cdev->private->flags.fake_irb) {
|
|
cdev->private->flags.fake_irb = FAKE_CMD_IRB;
|
|
cdev->private->intparm = intparm;
|
|
return 0;
|
|
} else
|
|
/* There's already a fake I/O around. */
|
|
return -EBUSY;
|
|
}
|
|
if (cdev->private->state != DEV_STATE_ONLINE ||
|
|
((sch->schib.scsw.cmd.stctl & SCSW_STCTL_PRIM_STATUS) &&
|
|
!(sch->schib.scsw.cmd.stctl & SCSW_STCTL_SEC_STATUS)) ||
|
|
cdev->private->flags.doverify)
|
|
return -EBUSY;
|
|
ret = cio_set_options (sch, flags);
|
|
if (ret)
|
|
return ret;
|
|
/* Adjust requested path mask to exclude unusable paths. */
|
|
if (lpm) {
|
|
lpm &= sch->lpm;
|
|
if (lpm == 0)
|
|
return -EACCES;
|
|
}
|
|
ret = cio_start_key (sch, cpa, lpm, key);
|
|
switch (ret) {
|
|
case 0:
|
|
cdev->private->intparm = intparm;
|
|
if (expires)
|
|
ccw_device_set_timeout(cdev, expires);
|
|
break;
|
|
case -EACCES:
|
|
case -ENODEV:
|
|
dev_fsm_event(cdev, DEV_EVENT_VERIFY);
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ccw_device_start_key() - start a s390 channel program with key
|
|
* @cdev: target ccw device
|
|
* @cpa: logical start address of channel program
|
|
* @intparm: user specific interruption parameter; will be presented back to
|
|
* @cdev's interrupt handler. Allows a device driver to associate
|
|
* the interrupt with a particular I/O request.
|
|
* @lpm: defines the channel path to be used for a specific I/O request. A
|
|
* value of 0 will make cio use the opm.
|
|
* @key: storage key to be used for the I/O
|
|
* @flags: additional flags; defines the action to be performed for I/O
|
|
* processing.
|
|
*
|
|
* Start a S/390 channel program. When the interrupt arrives, the
|
|
* IRQ handler is called, either immediately, delayed (dev-end missing,
|
|
* or sense required) or never (no IRQ handler registered).
|
|
* The interruption handler will echo back the @intparm specified here, unless
|
|
* another interruption parameter is specified by a subsequent invocation of
|
|
* ccw_device_halt() or ccw_device_clear().
|
|
* Returns:
|
|
* %0, if the operation was successful;
|
|
* -%EBUSY, if the device is busy, or status pending;
|
|
* -%EACCES, if no path specified in @lpm is operational;
|
|
* -%ENODEV, if the device is not operational.
|
|
* Context:
|
|
* Interrupts disabled, ccw device lock held
|
|
*/
|
|
int ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
|
|
unsigned long intparm, __u8 lpm, __u8 key,
|
|
unsigned long flags)
|
|
{
|
|
return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm, key,
|
|
flags, 0);
|
|
}
|
|
|
|
/**
|
|
* ccw_device_start() - start a s390 channel program
|
|
* @cdev: target ccw device
|
|
* @cpa: logical start address of channel program
|
|
* @intparm: user specific interruption parameter; will be presented back to
|
|
* @cdev's interrupt handler. Allows a device driver to associate
|
|
* the interrupt with a particular I/O request.
|
|
* @lpm: defines the channel path to be used for a specific I/O request. A
|
|
* value of 0 will make cio use the opm.
|
|
* @flags: additional flags; defines the action to be performed for I/O
|
|
* processing.
|
|
*
|
|
* Start a S/390 channel program. When the interrupt arrives, the
|
|
* IRQ handler is called, either immediately, delayed (dev-end missing,
|
|
* or sense required) or never (no IRQ handler registered).
|
|
* The interruption handler will echo back the @intparm specified here, unless
|
|
* another interruption parameter is specified by a subsequent invocation of
|
|
* ccw_device_halt() or ccw_device_clear().
|
|
* Returns:
|
|
* %0, if the operation was successful;
|
|
* -%EBUSY, if the device is busy, or status pending;
|
|
* -%EACCES, if no path specified in @lpm is operational;
|
|
* -%ENODEV, if the device is not operational.
|
|
* Context:
|
|
* Interrupts disabled, ccw device lock held
|
|
*/
|
|
int ccw_device_start(struct ccw_device *cdev, struct ccw1 *cpa,
|
|
unsigned long intparm, __u8 lpm, unsigned long flags)
|
|
{
|
|
return ccw_device_start_key(cdev, cpa, intparm, lpm,
|
|
PAGE_DEFAULT_KEY, flags);
|
|
}
|
|
|
|
/**
|
|
* ccw_device_start_timeout() - start a s390 channel program with timeout
|
|
* @cdev: target ccw device
|
|
* @cpa: logical start address of channel program
|
|
* @intparm: user specific interruption parameter; will be presented back to
|
|
* @cdev's interrupt handler. Allows a device driver to associate
|
|
* the interrupt with a particular I/O request.
|
|
* @lpm: defines the channel path to be used for a specific I/O request. A
|
|
* value of 0 will make cio use the opm.
|
|
* @flags: additional flags; defines the action to be performed for I/O
|
|
* processing.
|
|
* @expires: timeout value in jiffies
|
|
*
|
|
* Start a S/390 channel program. When the interrupt arrives, the
|
|
* IRQ handler is called, either immediately, delayed (dev-end missing,
|
|
* or sense required) or never (no IRQ handler registered).
|
|
* This function notifies the device driver if the channel program has not
|
|
* completed during the time specified by @expires. If a timeout occurs, the
|
|
* channel program is terminated via xsch, hsch or csch, and the device's
|
|
* interrupt handler will be called with an irb containing ERR_PTR(-%ETIMEDOUT).
|
|
* The interruption handler will echo back the @intparm specified here, unless
|
|
* another interruption parameter is specified by a subsequent invocation of
|
|
* ccw_device_halt() or ccw_device_clear().
|
|
* Returns:
|
|
* %0, if the operation was successful;
|
|
* -%EBUSY, if the device is busy, or status pending;
|
|
* -%EACCES, if no path specified in @lpm is operational;
|
|
* -%ENODEV, if the device is not operational.
|
|
* Context:
|
|
* Interrupts disabled, ccw device lock held
|
|
*/
|
|
int ccw_device_start_timeout(struct ccw_device *cdev, struct ccw1 *cpa,
|
|
unsigned long intparm, __u8 lpm,
|
|
unsigned long flags, int expires)
|
|
{
|
|
return ccw_device_start_timeout_key(cdev, cpa, intparm, lpm,
|
|
PAGE_DEFAULT_KEY, flags,
|
|
expires);
|
|
}
|
|
|
|
|
|
/**
|
|
* ccw_device_halt() - halt I/O request processing
|
|
* @cdev: target ccw device
|
|
* @intparm: interruption parameter to be returned upon conclusion of hsch
|
|
*
|
|
* ccw_device_halt() calls hsch on @cdev's subchannel.
|
|
* The interruption handler will echo back the @intparm specified here, unless
|
|
* another interruption parameter is specified by a subsequent invocation of
|
|
* ccw_device_clear().
|
|
* Returns:
|
|
* %0 on success,
|
|
* -%ENODEV on device not operational,
|
|
* -%EINVAL on invalid device state,
|
|
* -%EBUSY on device busy or interrupt pending.
|
|
* Context:
|
|
* Interrupts disabled, ccw device lock held
|
|
*/
|
|
int ccw_device_halt(struct ccw_device *cdev, unsigned long intparm)
|
|
{
|
|
struct subchannel *sch;
|
|
int ret;
|
|
|
|
if (!cdev || !cdev->dev.parent)
|
|
return -ENODEV;
|
|
sch = to_subchannel(cdev->dev.parent);
|
|
if (!sch->schib.pmcw.ena)
|
|
return -EINVAL;
|
|
if (cdev->private->state == DEV_STATE_NOT_OPER)
|
|
return -ENODEV;
|
|
if (cdev->private->state != DEV_STATE_ONLINE &&
|
|
cdev->private->state != DEV_STATE_W4SENSE)
|
|
return -EINVAL;
|
|
|
|
ret = cio_halt(sch);
|
|
if (ret == 0)
|
|
cdev->private->intparm = intparm;
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ccw_device_resume() - resume channel program execution
|
|
* @cdev: target ccw device
|
|
*
|
|
* ccw_device_resume() calls rsch on @cdev's subchannel.
|
|
* Returns:
|
|
* %0 on success,
|
|
* -%ENODEV on device not operational,
|
|
* -%EINVAL on invalid device state,
|
|
* -%EBUSY on device busy or interrupt pending.
|
|
* Context:
|
|
* Interrupts disabled, ccw device lock held
|
|
*/
|
|
int ccw_device_resume(struct ccw_device *cdev)
|
|
{
|
|
struct subchannel *sch;
|
|
|
|
if (!cdev || !cdev->dev.parent)
|
|
return -ENODEV;
|
|
sch = to_subchannel(cdev->dev.parent);
|
|
if (!sch->schib.pmcw.ena)
|
|
return -EINVAL;
|
|
if (cdev->private->state == DEV_STATE_NOT_OPER)
|
|
return -ENODEV;
|
|
if (cdev->private->state != DEV_STATE_ONLINE ||
|
|
!(sch->schib.scsw.cmd.actl & SCSW_ACTL_SUSPENDED))
|
|
return -EINVAL;
|
|
return cio_resume(sch);
|
|
}
|
|
|
|
/**
|
|
* ccw_device_get_ciw() - Search for CIW command in extended sense data.
|
|
* @cdev: ccw device to inspect
|
|
* @ct: command type to look for
|
|
*
|
|
* During SenseID, command information words (CIWs) describing special
|
|
* commands available to the device may have been stored in the extended
|
|
* sense data. This function searches for CIWs of a specified command
|
|
* type in the extended sense data.
|
|
* Returns:
|
|
* %NULL if no extended sense data has been stored or if no CIW of the
|
|
* specified command type could be found,
|
|
* else a pointer to the CIW of the specified command type.
|
|
*/
|
|
struct ciw *ccw_device_get_ciw(struct ccw_device *cdev, __u32 ct)
|
|
{
|
|
int ciw_cnt;
|
|
|
|
if (cdev->private->flags.esid == 0)
|
|
return NULL;
|
|
for (ciw_cnt = 0; ciw_cnt < MAX_CIWS; ciw_cnt++)
|
|
if (cdev->private->dma_area->senseid.ciw[ciw_cnt].ct == ct)
|
|
return cdev->private->dma_area->senseid.ciw + ciw_cnt;
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* ccw_device_get_path_mask() - get currently available paths
|
|
* @cdev: ccw device to be queried
|
|
* Returns:
|
|
* %0 if no subchannel for the device is available,
|
|
* else the mask of currently available paths for the ccw device's subchannel.
|
|
*/
|
|
__u8 ccw_device_get_path_mask(struct ccw_device *cdev)
|
|
{
|
|
struct subchannel *sch;
|
|
|
|
if (!cdev->dev.parent)
|
|
return 0;
|
|
|
|
sch = to_subchannel(cdev->dev.parent);
|
|
return sch->lpm;
|
|
}
|
|
|
|
/**
|
|
* ccw_device_get_chp_desc() - return newly allocated channel-path descriptor
|
|
* @cdev: device to obtain the descriptor for
|
|
* @chp_idx: index of the channel path
|
|
*
|
|
* On success return a newly allocated copy of the channel-path description
|
|
* data associated with the given channel path. Return %NULL on error.
|
|
*/
|
|
struct channel_path_desc_fmt0 *ccw_device_get_chp_desc(struct ccw_device *cdev,
|
|
int chp_idx)
|
|
{
|
|
struct subchannel *sch;
|
|
struct chp_id chpid;
|
|
|
|
sch = to_subchannel(cdev->dev.parent);
|
|
chp_id_init(&chpid);
|
|
chpid.id = sch->schib.pmcw.chpid[chp_idx];
|
|
return chp_get_chp_desc(chpid);
|
|
}
|
|
|
|
/**
|
|
* ccw_device_get_util_str() - return newly allocated utility strings
|
|
* @cdev: device to obtain the utility strings for
|
|
* @chp_idx: index of the channel path
|
|
*
|
|
* On success return a newly allocated copy of the utility strings
|
|
* associated with the given channel path. Return %NULL on error.
|
|
*/
|
|
u8 *ccw_device_get_util_str(struct ccw_device *cdev, int chp_idx)
|
|
{
|
|
struct subchannel *sch = to_subchannel(cdev->dev.parent);
|
|
struct channel_path *chp;
|
|
struct chp_id chpid;
|
|
u8 *util_str;
|
|
|
|
chp_id_init(&chpid);
|
|
chpid.id = sch->schib.pmcw.chpid[chp_idx];
|
|
chp = chpid_to_chp(chpid);
|
|
|
|
util_str = kmalloc(sizeof(chp->desc_fmt3.util_str), GFP_KERNEL);
|
|
if (!util_str)
|
|
return NULL;
|
|
|
|
mutex_lock(&chp->lock);
|
|
memcpy(util_str, chp->desc_fmt3.util_str, sizeof(chp->desc_fmt3.util_str));
|
|
mutex_unlock(&chp->lock);
|
|
|
|
return util_str;
|
|
}
|
|
|
|
/**
|
|
* ccw_device_get_id() - obtain a ccw device id
|
|
* @cdev: device to obtain the id for
|
|
* @dev_id: where to fill in the values
|
|
*/
|
|
void ccw_device_get_id(struct ccw_device *cdev, struct ccw_dev_id *dev_id)
|
|
{
|
|
*dev_id = cdev->private->dev_id;
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_get_id);
|
|
|
|
/**
|
|
* ccw_device_tm_start_timeout_key() - perform start function
|
|
* @cdev: ccw device on which to perform the start function
|
|
* @tcw: transport-command word to be started
|
|
* @intparm: user defined parameter to be passed to the interrupt handler
|
|
* @lpm: mask of paths to use
|
|
* @key: storage key to use for storage access
|
|
* @expires: time span in jiffies after which to abort request
|
|
*
|
|
* Start the tcw on the given ccw device. Return zero on success, non-zero
|
|
* otherwise.
|
|
*/
|
|
int ccw_device_tm_start_timeout_key(struct ccw_device *cdev, struct tcw *tcw,
|
|
unsigned long intparm, u8 lpm, u8 key,
|
|
int expires)
|
|
{
|
|
struct subchannel *sch;
|
|
int rc;
|
|
|
|
sch = to_subchannel(cdev->dev.parent);
|
|
if (!sch->schib.pmcw.ena)
|
|
return -EINVAL;
|
|
if (cdev->private->state == DEV_STATE_VERIFY) {
|
|
/* Remember to fake irb when finished. */
|
|
if (!cdev->private->flags.fake_irb) {
|
|
cdev->private->flags.fake_irb = FAKE_TM_IRB;
|
|
cdev->private->intparm = intparm;
|
|
return 0;
|
|
} else
|
|
/* There's already a fake I/O around. */
|
|
return -EBUSY;
|
|
}
|
|
if (cdev->private->state != DEV_STATE_ONLINE)
|
|
return -EIO;
|
|
/* Adjust requested path mask to exclude unusable paths. */
|
|
if (lpm) {
|
|
lpm &= sch->lpm;
|
|
if (lpm == 0)
|
|
return -EACCES;
|
|
}
|
|
rc = cio_tm_start_key(sch, tcw, lpm, key);
|
|
if (rc == 0) {
|
|
cdev->private->intparm = intparm;
|
|
if (expires)
|
|
ccw_device_set_timeout(cdev, expires);
|
|
}
|
|
return rc;
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_tm_start_timeout_key);
|
|
|
|
/**
|
|
* ccw_device_tm_start_key() - perform start function
|
|
* @cdev: ccw device on which to perform the start function
|
|
* @tcw: transport-command word to be started
|
|
* @intparm: user defined parameter to be passed to the interrupt handler
|
|
* @lpm: mask of paths to use
|
|
* @key: storage key to use for storage access
|
|
*
|
|
* Start the tcw on the given ccw device. Return zero on success, non-zero
|
|
* otherwise.
|
|
*/
|
|
int ccw_device_tm_start_key(struct ccw_device *cdev, struct tcw *tcw,
|
|
unsigned long intparm, u8 lpm, u8 key)
|
|
{
|
|
return ccw_device_tm_start_timeout_key(cdev, tcw, intparm, lpm, key, 0);
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_tm_start_key);
|
|
|
|
/**
|
|
* ccw_device_tm_start() - perform start function
|
|
* @cdev: ccw device on which to perform the start function
|
|
* @tcw: transport-command word to be started
|
|
* @intparm: user defined parameter to be passed to the interrupt handler
|
|
* @lpm: mask of paths to use
|
|
*
|
|
* Start the tcw on the given ccw device. Return zero on success, non-zero
|
|
* otherwise.
|
|
*/
|
|
int ccw_device_tm_start(struct ccw_device *cdev, struct tcw *tcw,
|
|
unsigned long intparm, u8 lpm)
|
|
{
|
|
return ccw_device_tm_start_key(cdev, tcw, intparm, lpm,
|
|
PAGE_DEFAULT_KEY);
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_tm_start);
|
|
|
|
/**
|
|
* ccw_device_tm_start_timeout() - perform start function
|
|
* @cdev: ccw device on which to perform the start function
|
|
* @tcw: transport-command word to be started
|
|
* @intparm: user defined parameter to be passed to the interrupt handler
|
|
* @lpm: mask of paths to use
|
|
* @expires: time span in jiffies after which to abort request
|
|
*
|
|
* Start the tcw on the given ccw device. Return zero on success, non-zero
|
|
* otherwise.
|
|
*/
|
|
int ccw_device_tm_start_timeout(struct ccw_device *cdev, struct tcw *tcw,
|
|
unsigned long intparm, u8 lpm, int expires)
|
|
{
|
|
return ccw_device_tm_start_timeout_key(cdev, tcw, intparm, lpm,
|
|
PAGE_DEFAULT_KEY, expires);
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_tm_start_timeout);
|
|
|
|
/**
|
|
* ccw_device_get_mdc() - accumulate max data count
|
|
* @cdev: ccw device for which the max data count is accumulated
|
|
* @mask: mask of paths to use
|
|
*
|
|
* Return the number of 64K-bytes blocks all paths at least support
|
|
* for a transport command. Return value 0 indicates failure.
|
|
*/
|
|
int ccw_device_get_mdc(struct ccw_device *cdev, u8 mask)
|
|
{
|
|
struct subchannel *sch = to_subchannel(cdev->dev.parent);
|
|
struct channel_path *chp;
|
|
struct chp_id chpid;
|
|
int mdc = 0, i;
|
|
|
|
/* Adjust requested path mask to excluded varied off paths. */
|
|
if (mask)
|
|
mask &= sch->lpm;
|
|
else
|
|
mask = sch->lpm;
|
|
|
|
chp_id_init(&chpid);
|
|
for (i = 0; i < 8; i++) {
|
|
if (!(mask & (0x80 >> i)))
|
|
continue;
|
|
chpid.id = sch->schib.pmcw.chpid[i];
|
|
chp = chpid_to_chp(chpid);
|
|
if (!chp)
|
|
continue;
|
|
|
|
mutex_lock(&chp->lock);
|
|
if (!chp->desc_fmt1.f) {
|
|
mutex_unlock(&chp->lock);
|
|
return 0;
|
|
}
|
|
if (!chp->desc_fmt1.r)
|
|
mdc = 1;
|
|
mdc = mdc ? min_t(int, mdc, chp->desc_fmt1.mdc) :
|
|
chp->desc_fmt1.mdc;
|
|
mutex_unlock(&chp->lock);
|
|
}
|
|
|
|
return mdc;
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_get_mdc);
|
|
|
|
/**
|
|
* ccw_device_tm_intrg() - perform interrogate function
|
|
* @cdev: ccw device on which to perform the interrogate function
|
|
*
|
|
* Perform an interrogate function on the given ccw device. Return zero on
|
|
* success, non-zero otherwise.
|
|
*/
|
|
int ccw_device_tm_intrg(struct ccw_device *cdev)
|
|
{
|
|
struct subchannel *sch = to_subchannel(cdev->dev.parent);
|
|
|
|
if (!sch->schib.pmcw.ena)
|
|
return -EINVAL;
|
|
if (cdev->private->state != DEV_STATE_ONLINE)
|
|
return -EIO;
|
|
if (!scsw_is_tm(&sch->schib.scsw) ||
|
|
!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_START_PEND))
|
|
return -EINVAL;
|
|
return cio_tm_intrg(sch);
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_tm_intrg);
|
|
|
|
/**
|
|
* ccw_device_get_schid() - obtain a subchannel id
|
|
* @cdev: device to obtain the id for
|
|
* @schid: where to fill in the values
|
|
*/
|
|
void ccw_device_get_schid(struct ccw_device *cdev, struct subchannel_id *schid)
|
|
{
|
|
struct subchannel *sch = to_subchannel(cdev->dev.parent);
|
|
|
|
*schid = sch->schid;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ccw_device_get_schid);
|
|
|
|
/**
|
|
* ccw_device_pnso() - Perform Network-Subchannel Operation
|
|
* @cdev: device on which PNSO is performed
|
|
* @pnso_area: request and response block for the operation
|
|
* @oc: Operation Code
|
|
* @resume_token: resume token for multiblock response
|
|
* @cnc: Boolean change-notification control
|
|
*
|
|
* pnso_area must be allocated by the caller with get_zeroed_page(GFP_KERNEL)
|
|
*
|
|
* Returns 0 on success.
|
|
*/
|
|
int ccw_device_pnso(struct ccw_device *cdev,
|
|
struct chsc_pnso_area *pnso_area, u8 oc,
|
|
struct chsc_pnso_resume_token resume_token, int cnc)
|
|
{
|
|
struct subchannel_id schid;
|
|
|
|
ccw_device_get_schid(cdev, &schid);
|
|
return chsc_pnso(schid, pnso_area, oc, resume_token, cnc);
|
|
}
|
|
EXPORT_SYMBOL_GPL(ccw_device_pnso);
|
|
|
|
/**
|
|
* ccw_device_get_cssid() - obtain Channel Subsystem ID
|
|
* @cdev: device to obtain the CSSID for
|
|
* @cssid: The resulting Channel Subsystem ID
|
|
*/
|
|
int ccw_device_get_cssid(struct ccw_device *cdev, u8 *cssid)
|
|
{
|
|
struct device *sch_dev = cdev->dev.parent;
|
|
struct channel_subsystem *css = to_css(sch_dev->parent);
|
|
|
|
if (css->id_valid)
|
|
*cssid = css->cssid;
|
|
return css->id_valid ? 0 : -ENODEV;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ccw_device_get_cssid);
|
|
|
|
/**
|
|
* ccw_device_get_iid() - obtain MIF-image ID
|
|
* @cdev: device to obtain the MIF-image ID for
|
|
* @iid: The resulting MIF-image ID
|
|
*/
|
|
int ccw_device_get_iid(struct ccw_device *cdev, u8 *iid)
|
|
{
|
|
struct device *sch_dev = cdev->dev.parent;
|
|
struct channel_subsystem *css = to_css(sch_dev->parent);
|
|
|
|
if (css->id_valid)
|
|
*iid = css->iid;
|
|
return css->id_valid ? 0 : -ENODEV;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ccw_device_get_iid);
|
|
|
|
/**
|
|
* ccw_device_get_chpid() - obtain Channel Path ID
|
|
* @cdev: device to obtain the Channel Path ID for
|
|
* @chp_idx: Index of the channel path
|
|
* @chpid: The resulting Channel Path ID
|
|
*/
|
|
int ccw_device_get_chpid(struct ccw_device *cdev, int chp_idx, u8 *chpid)
|
|
{
|
|
struct subchannel *sch = to_subchannel(cdev->dev.parent);
|
|
int mask;
|
|
|
|
if ((chp_idx < 0) || (chp_idx > 7))
|
|
return -EINVAL;
|
|
mask = 0x80 >> chp_idx;
|
|
if (!(sch->schib.pmcw.pim & mask))
|
|
return -ENODEV;
|
|
|
|
*chpid = sch->schib.pmcw.chpid[chp_idx];
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ccw_device_get_chpid);
|
|
|
|
/**
|
|
* ccw_device_get_chid() - obtain Channel ID associated with specified CHPID
|
|
* @cdev: device to obtain the Channel ID for
|
|
* @chp_idx: Index of the channel path
|
|
* @chid: The resulting Channel ID
|
|
*/
|
|
int ccw_device_get_chid(struct ccw_device *cdev, int chp_idx, u16 *chid)
|
|
{
|
|
struct chp_id cssid_chpid;
|
|
struct channel_path *chp;
|
|
int rc;
|
|
|
|
chp_id_init(&cssid_chpid);
|
|
rc = ccw_device_get_chpid(cdev, chp_idx, &cssid_chpid.id);
|
|
if (rc)
|
|
return rc;
|
|
chp = chpid_to_chp(cssid_chpid);
|
|
if (!chp)
|
|
return -ENODEV;
|
|
|
|
mutex_lock(&chp->lock);
|
|
if (chp->desc_fmt1.flags & 0x10)
|
|
*chid = chp->desc_fmt1.chid;
|
|
else
|
|
rc = -ENODEV;
|
|
mutex_unlock(&chp->lock);
|
|
|
|
return rc;
|
|
}
|
|
EXPORT_SYMBOL_GPL(ccw_device_get_chid);
|
|
|
|
/*
|
|
* Allocate zeroed dma coherent 31 bit addressable memory using
|
|
* the subchannels dma pool. Maximal size of allocation supported
|
|
* is PAGE_SIZE.
|
|
*/
|
|
void *ccw_device_dma_zalloc(struct ccw_device *cdev, size_t size)
|
|
{
|
|
void *addr;
|
|
|
|
if (!get_device(&cdev->dev))
|
|
return NULL;
|
|
addr = cio_gp_dma_zalloc(cdev->private->dma_pool, &cdev->dev, size);
|
|
if (IS_ERR_OR_NULL(addr))
|
|
put_device(&cdev->dev);
|
|
return addr;
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_dma_zalloc);
|
|
|
|
void ccw_device_dma_free(struct ccw_device *cdev, void *cpu_addr, size_t size)
|
|
{
|
|
if (!cpu_addr)
|
|
return;
|
|
cio_gp_dma_free(cdev->private->dma_pool, cpu_addr, size);
|
|
put_device(&cdev->dev);
|
|
}
|
|
EXPORT_SYMBOL(ccw_device_dma_free);
|
|
|
|
EXPORT_SYMBOL(ccw_device_set_options_mask);
|
|
EXPORT_SYMBOL(ccw_device_set_options);
|
|
EXPORT_SYMBOL(ccw_device_clear_options);
|
|
EXPORT_SYMBOL(ccw_device_clear);
|
|
EXPORT_SYMBOL(ccw_device_halt);
|
|
EXPORT_SYMBOL(ccw_device_resume);
|
|
EXPORT_SYMBOL(ccw_device_start_timeout);
|
|
EXPORT_SYMBOL(ccw_device_start);
|
|
EXPORT_SYMBOL(ccw_device_start_timeout_key);
|
|
EXPORT_SYMBOL(ccw_device_start_key);
|
|
EXPORT_SYMBOL(ccw_device_get_ciw);
|
|
EXPORT_SYMBOL(ccw_device_get_path_mask);
|
|
EXPORT_SYMBOL_GPL(ccw_device_get_chp_desc);
|
|
EXPORT_SYMBOL_GPL(ccw_device_get_util_str);
|