xref: /openbmc/linux/drivers/scsi/cxlflash/lunmgt.c (revision 2874c5fd)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * CXL Flash Device Driver
4  *
5  * Written by: Manoj N. Kumar <manoj@linux.vnet.ibm.com>, IBM Corporation
6  *             Matthew R. Ochs <mrochs@linux.vnet.ibm.com>, IBM Corporation
7  *
8  * Copyright (C) 2015 IBM Corporation
9  */
10 
11 #include <asm/unaligned.h>
12 
13 #include <linux/interrupt.h>
14 #include <linux/pci.h>
15 
16 #include <scsi/scsi_host.h>
17 #include <uapi/scsi/cxlflash_ioctl.h>
18 
19 #include "sislite.h"
20 #include "common.h"
21 #include "vlun.h"
22 #include "superpipe.h"
23 
24 /**
25  * create_local() - allocate and initialize a local LUN information structure
26  * @sdev:	SCSI device associated with LUN.
27  * @wwid:	World Wide Node Name for LUN.
28  *
29  * Return: Allocated local llun_info structure on success, NULL on failure
30  */
create_local(struct scsi_device * sdev,u8 * wwid)31 static struct llun_info *create_local(struct scsi_device *sdev, u8 *wwid)
32 {
33 	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
34 	struct device *dev = &cfg->dev->dev;
35 	struct llun_info *lli = NULL;
36 
37 	lli = kzalloc(sizeof(*lli), GFP_KERNEL);
38 	if (unlikely(!lli)) {
39 		dev_err(dev, "%s: could not allocate lli\n", __func__);
40 		goto out;
41 	}
42 
43 	lli->sdev = sdev;
44 	lli->host_no = sdev->host->host_no;
45 	lli->in_table = false;
46 
47 	memcpy(lli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN);
48 out:
49 	return lli;
50 }
51 
52 /**
53  * create_global() - allocate and initialize a global LUN information structure
54  * @sdev:	SCSI device associated with LUN.
55  * @wwid:	World Wide Node Name for LUN.
56  *
57  * Return: Allocated global glun_info structure on success, NULL on failure
58  */
create_global(struct scsi_device * sdev,u8 * wwid)59 static struct glun_info *create_global(struct scsi_device *sdev, u8 *wwid)
60 {
61 	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
62 	struct device *dev = &cfg->dev->dev;
63 	struct glun_info *gli = NULL;
64 
65 	gli = kzalloc(sizeof(*gli), GFP_KERNEL);
66 	if (unlikely(!gli)) {
67 		dev_err(dev, "%s: could not allocate gli\n", __func__);
68 		goto out;
69 	}
70 
71 	mutex_init(&gli->mutex);
72 	memcpy(gli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN);
73 out:
74 	return gli;
75 }
76 
77 /**
78  * lookup_local() - find a local LUN information structure by WWID
79  * @cfg:	Internal structure associated with the host.
80  * @wwid:	WWID associated with LUN.
81  *
82  * Return: Found local lun_info structure on success, NULL on failure
83  */
lookup_local(struct cxlflash_cfg * cfg,u8 * wwid)84 static struct llun_info *lookup_local(struct cxlflash_cfg *cfg, u8 *wwid)
85 {
86 	struct llun_info *lli, *temp;
87 
88 	list_for_each_entry_safe(lli, temp, &cfg->lluns, list)
89 		if (!memcmp(lli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN))
90 			return lli;
91 
92 	return NULL;
93 }
94 
95 /**
96  * lookup_global() - find a global LUN information structure by WWID
97  * @wwid:	WWID associated with LUN.
98  *
99  * Return: Found global lun_info structure on success, NULL on failure
100  */
lookup_global(u8 * wwid)101 static struct glun_info *lookup_global(u8 *wwid)
102 {
103 	struct glun_info *gli, *temp;
104 
105 	list_for_each_entry_safe(gli, temp, &global.gluns, list)
106 		if (!memcmp(gli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN))
107 			return gli;
108 
109 	return NULL;
110 }
111 
112 /**
113  * find_and_create_lun() - find or create a local LUN information structure
114  * @sdev:	SCSI device associated with LUN.
115  * @wwid:	WWID associated with LUN.
116  *
117  * The LUN is kept both in a local list (per adapter) and in a global list
118  * (across all adapters). Certain attributes of the LUN are local to the
119  * adapter (such as index, port selection mask, etc.).
120  *
121  * The block allocation map is shared across all adapters (i.e. associated
122  * wih the global list). Since different attributes are associated with
123  * the per adapter and global entries, allocate two separate structures for each
124  * LUN (one local, one global).
125  *
126  * Keep a pointer back from the local to the global entry.
127  *
128  * This routine assumes the caller holds the global mutex.
129  *
130  * Return: Found/Allocated local lun_info structure on success, NULL on failure
131  */
find_and_create_lun(struct scsi_device * sdev,u8 * wwid)132 static struct llun_info *find_and_create_lun(struct scsi_device *sdev, u8 *wwid)
133 {
134 	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
135 	struct device *dev = &cfg->dev->dev;
136 	struct llun_info *lli = NULL;
137 	struct glun_info *gli = NULL;
138 
139 	if (unlikely(!wwid))
140 		goto out;
141 
142 	lli = lookup_local(cfg, wwid);
143 	if (lli)
144 		goto out;
145 
146 	lli = create_local(sdev, wwid);
147 	if (unlikely(!lli))
148 		goto out;
149 
150 	gli = lookup_global(wwid);
151 	if (gli) {
152 		lli->parent = gli;
153 		list_add(&lli->list, &cfg->lluns);
154 		goto out;
155 	}
156 
157 	gli = create_global(sdev, wwid);
158 	if (unlikely(!gli)) {
159 		kfree(lli);
160 		lli = NULL;
161 		goto out;
162 	}
163 
164 	lli->parent = gli;
165 	list_add(&lli->list, &cfg->lluns);
166 
167 	list_add(&gli->list, &global.gluns);
168 
169 out:
170 	dev_dbg(dev, "%s: returning lli=%p, gli=%p\n", __func__, lli, gli);
171 	return lli;
172 }
173 
174 /**
175  * cxlflash_term_local_luns() - Delete all entries from local LUN list, free.
176  * @cfg:	Internal structure associated with the host.
177  */
cxlflash_term_local_luns(struct cxlflash_cfg * cfg)178 void cxlflash_term_local_luns(struct cxlflash_cfg *cfg)
179 {
180 	struct llun_info *lli, *temp;
181 
182 	mutex_lock(&global.mutex);
183 	list_for_each_entry_safe(lli, temp, &cfg->lluns, list) {
184 		list_del(&lli->list);
185 		kfree(lli);
186 	}
187 	mutex_unlock(&global.mutex);
188 }
189 
190 /**
191  * cxlflash_list_init() - initializes the global LUN list
192  */
cxlflash_list_init(void)193 void cxlflash_list_init(void)
194 {
195 	INIT_LIST_HEAD(&global.gluns);
196 	mutex_init(&global.mutex);
197 	global.err_page = NULL;
198 }
199 
200 /**
201  * cxlflash_term_global_luns() - frees resources associated with global LUN list
202  */
cxlflash_term_global_luns(void)203 void cxlflash_term_global_luns(void)
204 {
205 	struct glun_info *gli, *temp;
206 
207 	mutex_lock(&global.mutex);
208 	list_for_each_entry_safe(gli, temp, &global.gluns, list) {
209 		list_del(&gli->list);
210 		cxlflash_ba_terminate(&gli->blka.ba_lun);
211 		kfree(gli);
212 	}
213 	mutex_unlock(&global.mutex);
214 }
215 
216 /**
217  * cxlflash_manage_lun() - handles LUN management activities
218  * @sdev:	SCSI device associated with LUN.
219  * @manage:	Manage ioctl data structure.
220  *
221  * This routine is used to notify the driver about a LUN's WWID and associate
222  * SCSI devices (sdev) with a global LUN instance. Additionally it serves to
223  * change a LUN's operating mode: legacy or superpipe.
224  *
225  * Return: 0 on success, -errno on failure
226  */
cxlflash_manage_lun(struct scsi_device * sdev,struct dk_cxlflash_manage_lun * manage)227 int cxlflash_manage_lun(struct scsi_device *sdev,
228 			struct dk_cxlflash_manage_lun *manage)
229 {
230 	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
231 	struct device *dev = &cfg->dev->dev;
232 	struct llun_info *lli = NULL;
233 	int rc = 0;
234 	u64 flags = manage->hdr.flags;
235 	u32 chan = sdev->channel;
236 
237 	mutex_lock(&global.mutex);
238 	lli = find_and_create_lun(sdev, manage->wwid);
239 	dev_dbg(dev, "%s: WWID=%016llx%016llx, flags=%016llx lli=%p\n",
240 		__func__, get_unaligned_be64(&manage->wwid[0]),
241 		get_unaligned_be64(&manage->wwid[8]), manage->hdr.flags, lli);
242 	if (unlikely(!lli)) {
243 		rc = -ENOMEM;
244 		goto out;
245 	}
246 
247 	if (flags & DK_CXLFLASH_MANAGE_LUN_ENABLE_SUPERPIPE) {
248 		/*
249 		 * Update port selection mask based upon channel, store off LUN
250 		 * in unpacked, AFU-friendly format, and hang LUN reference in
251 		 * the sdev.
252 		 */
253 		lli->port_sel |= CHAN2PORTMASK(chan);
254 		lli->lun_id[chan] = lun_to_lunid(sdev->lun);
255 		sdev->hostdata = lli;
256 	} else if (flags & DK_CXLFLASH_MANAGE_LUN_DISABLE_SUPERPIPE) {
257 		if (lli->parent->mode != MODE_NONE)
258 			rc = -EBUSY;
259 		else {
260 			/*
261 			 * Clean up local LUN for this port and reset table
262 			 * tracking when no more references exist.
263 			 */
264 			sdev->hostdata = NULL;
265 			lli->port_sel &= ~CHAN2PORTMASK(chan);
266 			if (lli->port_sel == 0U)
267 				lli->in_table = false;
268 		}
269 	}
270 
271 	dev_dbg(dev, "%s: port_sel=%08x chan=%u lun_id=%016llx\n",
272 		__func__, lli->port_sel, chan, lli->lun_id[chan]);
273 
274 out:
275 	mutex_unlock(&global.mutex);
276 	dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
277 	return rc;
278 }
279