mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-28 11:18:45 +07:00
0558f33c06
In commit 87c8331fcf ("[SCSI] libsas: prevent domain rediscovery
competing with ata error handling") introduced disco mutex to prevent
rediscovery competing with ata error handling and put the whole
revalidation in the mutex. But the rphy add/remove needs to wait for the
error handling which also grabs the disco mutex. This may leads to dead
lock.So the probe and destruct event were introduce to do the rphy
add/remove asynchronously and out of the lock.
The asynchronously processed workers makes the whole discovery process
not atomic, the other events may interrupt the process. For example,
if a loss of signal event inserted before the probe event, the
sas_deform_port() is called and the port will be deleted.
And sas_port_delete() may run before the destruct event, but the
port-x:x is the top parent of end device or expander. This leads to
a kernel WARNING such as:
[ 82.042979] sysfs group 'power' not found for kobject 'phy-1:0:22'
[ 82.042983] ------------[ cut here ]------------
[ 82.042986] WARNING: CPU: 54 PID: 1714 at fs/sysfs/group.c:237
sysfs_remove_group+0x94/0xa0
[ 82.043059] Call trace:
[ 82.043082] [<ffff0000082e7624>] sysfs_remove_group+0x94/0xa0
[ 82.043085] [<ffff00000864e320>] dpm_sysfs_remove+0x60/0x70
[ 82.043086] [<ffff00000863ee10>] device_del+0x138/0x308
[ 82.043089] [<ffff00000869a2d0>] sas_phy_delete+0x38/0x60
[ 82.043091] [<ffff00000869a86c>] do_sas_phy_delete+0x6c/0x80
[ 82.043093] [<ffff00000863dc20>] device_for_each_child+0x58/0xa0
[ 82.043095] [<ffff000008696f80>] sas_remove_children+0x40/0x50
[ 82.043100] [<ffff00000869d1bc>] sas_destruct_devices+0x64/0xa0
[ 82.043102] [<ffff0000080e93bc>] process_one_work+0x1fc/0x4b0
[ 82.043104] [<ffff0000080e96c0>] worker_thread+0x50/0x490
[ 82.043105] [<ffff0000080f0364>] kthread+0xfc/0x128
[ 82.043107] [<ffff0000080836c0>] ret_from_fork+0x10/0x50
Make probe and destruct a direct call in the disco and revalidate function,
but put them outside the lock. The whole discovery or revalidate won't
be interrupted by other events. And the DISCE_PROBE and DISCE_DESTRUCT
event are deleted as a result of the direct call.
Introduce a new list to destruct the sas_port and put the port delete after
the destruct. This makes sure the right order of destroying the sysfs
kobject and fix the warning above.
In sas_ex_revalidate_domain() have a loop to find all broadcasted
device, and sometimes we have a chance to find the same expander twice.
Because the sas_port will be deleted at the end of the whole revalidate
process, sas_port with the same name cannot be added before this.
Otherwise the sysfs will complain of creating duplicate filename. Since
the LLDD will send broadcast for every device change, we can only
process one expander's revalidation.
[mkp: kbuild test robot warning]
Signed-off-by: Jason Yan <yanaijie@huawei.com>
CC: John Garry <john.garry@huawei.com>
CC: Johannes Thumshirn <jthumshirn@suse.de>
CC: Ewan Milne <emilne@redhat.com>
CC: Christoph Hellwig <hch@lst.de>
CC: Tomas Henzl <thenzl@redhat.com>
CC: Dan Williams <dan.j.williams@intel.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
206 lines
6.6 KiB
C
206 lines
6.6 KiB
C
/*
|
|
* Serial Attached SCSI (SAS) class internal header file
|
|
*
|
|
* Copyright (C) 2005 Adaptec, Inc. All rights reserved.
|
|
* Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
|
|
*
|
|
* This file is licensed under GPLv2.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
|
* USA
|
|
*
|
|
*/
|
|
|
|
#ifndef _SAS_INTERNAL_H_
|
|
#define _SAS_INTERNAL_H_
|
|
|
|
#include <scsi/scsi.h>
|
|
#include <scsi/scsi_host.h>
|
|
#include <scsi/scsi_transport_sas.h>
|
|
#include <scsi/libsas.h>
|
|
#include <scsi/sas_ata.h>
|
|
|
|
#define sas_printk(fmt, ...) printk(KERN_NOTICE "sas: " fmt, ## __VA_ARGS__)
|
|
|
|
#define SAS_DPRINTK(fmt, ...) printk(KERN_DEBUG "sas: " fmt, ## __VA_ARGS__)
|
|
|
|
#define TO_SAS_TASK(_scsi_cmd) ((void *)(_scsi_cmd)->host_scribble)
|
|
#define ASSIGN_SAS_TASK(_sc, _t) do { (_sc)->host_scribble = (void *) _t; } while (0)
|
|
|
|
struct sas_phy_data {
|
|
/* let reset be performed in sas_queue_work() context */
|
|
struct sas_phy *phy;
|
|
struct mutex event_lock;
|
|
int hard_reset;
|
|
int reset_result;
|
|
struct sas_work reset_work;
|
|
int enable;
|
|
int enable_result;
|
|
struct sas_work enable_work;
|
|
};
|
|
|
|
void sas_scsi_recover_host(struct Scsi_Host *shost);
|
|
|
|
int sas_show_class(enum sas_class class, char *buf);
|
|
int sas_show_proto(enum sas_protocol proto, char *buf);
|
|
int sas_show_linkrate(enum sas_linkrate linkrate, char *buf);
|
|
int sas_show_oob_mode(enum sas_oob_mode oob_mode, char *buf);
|
|
|
|
int sas_register_phys(struct sas_ha_struct *sas_ha);
|
|
void sas_unregister_phys(struct sas_ha_struct *sas_ha);
|
|
|
|
struct asd_sas_event *sas_alloc_event(struct asd_sas_phy *phy);
|
|
void sas_free_event(struct asd_sas_event *event);
|
|
|
|
int sas_register_ports(struct sas_ha_struct *sas_ha);
|
|
void sas_unregister_ports(struct sas_ha_struct *sas_ha);
|
|
|
|
int sas_init_events(struct sas_ha_struct *sas_ha);
|
|
void sas_disable_revalidation(struct sas_ha_struct *ha);
|
|
void sas_enable_revalidation(struct sas_ha_struct *ha);
|
|
void __sas_drain_work(struct sas_ha_struct *ha);
|
|
|
|
void sas_deform_port(struct asd_sas_phy *phy, int gone);
|
|
|
|
void sas_porte_bytes_dmaed(struct work_struct *work);
|
|
void sas_porte_broadcast_rcvd(struct work_struct *work);
|
|
void sas_porte_link_reset_err(struct work_struct *work);
|
|
void sas_porte_timer_event(struct work_struct *work);
|
|
void sas_porte_hard_reset(struct work_struct *work);
|
|
int sas_queue_work(struct sas_ha_struct *ha, struct sas_work *sw);
|
|
|
|
int sas_notify_lldd_dev_found(struct domain_device *);
|
|
void sas_notify_lldd_dev_gone(struct domain_device *);
|
|
|
|
void sas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
|
|
struct sas_rphy *rphy);
|
|
int sas_smp_phy_control(struct domain_device *dev, int phy_id,
|
|
enum phy_func phy_func, struct sas_phy_linkrates *);
|
|
int sas_smp_get_phy_events(struct sas_phy *phy);
|
|
|
|
int sas_notify_phy_event(struct asd_sas_phy *phy, enum phy_event event);
|
|
void sas_device_set_phy(struct domain_device *dev, struct sas_port *port);
|
|
struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy);
|
|
struct domain_device *sas_ex_to_ata(struct domain_device *ex_dev, int phy_id);
|
|
int sas_ex_phy_discover(struct domain_device *dev, int single);
|
|
int sas_get_report_phy_sata(struct domain_device *dev, int phy_id,
|
|
struct smp_resp *rps_resp);
|
|
int sas_try_ata_reset(struct asd_sas_phy *phy);
|
|
void sas_hae_reset(struct work_struct *work);
|
|
|
|
void sas_free_device(struct kref *kref);
|
|
void sas_destruct_devices(struct asd_sas_port *port);
|
|
|
|
extern const work_func_t sas_phy_event_fns[PHY_NUM_EVENTS];
|
|
extern const work_func_t sas_port_event_fns[PORT_NUM_EVENTS];
|
|
|
|
#ifdef CONFIG_SCSI_SAS_HOST_SMP
|
|
extern void sas_smp_host_handler(struct bsg_job *job, struct Scsi_Host *shost);
|
|
#else
|
|
static inline void sas_smp_host_handler(struct bsg_job *job,
|
|
struct Scsi_Host *shost)
|
|
{
|
|
shost_printk(KERN_ERR, shost,
|
|
"Cannot send SMP to a sas host (not enabled in CONFIG)\n");
|
|
bsg_job_done(job, -EINVAL, 0);
|
|
}
|
|
#endif
|
|
|
|
static inline void sas_fail_probe(struct domain_device *dev, const char *func, int err)
|
|
{
|
|
SAS_DPRINTK("%s: for %s device %16llx returned %d\n",
|
|
func, dev->parent ? "exp-attached" :
|
|
"direct-attached",
|
|
SAS_ADDR(dev->sas_addr), err);
|
|
sas_unregister_dev(dev->port, dev);
|
|
}
|
|
|
|
static inline void sas_fill_in_rphy(struct domain_device *dev,
|
|
struct sas_rphy *rphy)
|
|
{
|
|
rphy->identify.sas_address = SAS_ADDR(dev->sas_addr);
|
|
rphy->identify.initiator_port_protocols = dev->iproto;
|
|
rphy->identify.target_port_protocols = dev->tproto;
|
|
switch (dev->dev_type) {
|
|
case SAS_SATA_DEV:
|
|
/* FIXME: need sata device type */
|
|
case SAS_END_DEVICE:
|
|
case SAS_SATA_PENDING:
|
|
rphy->identify.device_type = SAS_END_DEVICE;
|
|
break;
|
|
case SAS_EDGE_EXPANDER_DEVICE:
|
|
rphy->identify.device_type = SAS_EDGE_EXPANDER_DEVICE;
|
|
break;
|
|
case SAS_FANOUT_EXPANDER_DEVICE:
|
|
rphy->identify.device_type = SAS_FANOUT_EXPANDER_DEVICE;
|
|
break;
|
|
default:
|
|
rphy->identify.device_type = SAS_PHY_UNUSED;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static inline void sas_phy_set_target(struct asd_sas_phy *p, struct domain_device *dev)
|
|
{
|
|
struct sas_phy *phy = p->phy;
|
|
|
|
if (dev) {
|
|
if (dev_is_sata(dev))
|
|
phy->identify.device_type = SAS_END_DEVICE;
|
|
else
|
|
phy->identify.device_type = dev->dev_type;
|
|
phy->identify.target_port_protocols = dev->tproto;
|
|
} else {
|
|
phy->identify.device_type = SAS_PHY_UNUSED;
|
|
phy->identify.target_port_protocols = 0;
|
|
}
|
|
}
|
|
|
|
static inline void sas_add_parent_port(struct domain_device *dev, int phy_id)
|
|
{
|
|
struct expander_device *ex = &dev->ex_dev;
|
|
struct ex_phy *ex_phy = &ex->ex_phy[phy_id];
|
|
|
|
if (!ex->parent_port) {
|
|
ex->parent_port = sas_port_alloc(&dev->rphy->dev, phy_id);
|
|
/* FIXME: error handling */
|
|
BUG_ON(!ex->parent_port);
|
|
BUG_ON(sas_port_add(ex->parent_port));
|
|
sas_port_mark_backlink(ex->parent_port);
|
|
}
|
|
sas_port_add_phy(ex->parent_port, ex_phy->phy);
|
|
}
|
|
|
|
static inline struct domain_device *sas_alloc_device(void)
|
|
{
|
|
struct domain_device *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
|
|
|
if (dev) {
|
|
INIT_LIST_HEAD(&dev->siblings);
|
|
INIT_LIST_HEAD(&dev->dev_list_node);
|
|
INIT_LIST_HEAD(&dev->disco_list_node);
|
|
kref_init(&dev->kref);
|
|
spin_lock_init(&dev->done_lock);
|
|
}
|
|
return dev;
|
|
}
|
|
|
|
static inline void sas_put_device(struct domain_device *dev)
|
|
{
|
|
kref_put(&dev->kref, sas_free_device);
|
|
}
|
|
|
|
#endif /* _SAS_INTERNAL_H_ */
|