xref: /openbmc/linux/drivers/scsi/cxlflash/vlun.c (revision 1ac731c529cd4d6adbce134754b51ff7d822b145)
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 <linux/interrupt.h>
12  #include <linux/pci.h>
13  #include <linux/syscalls.h>
14  #include <asm/unaligned.h>
15  #include <asm/bitsperlong.h>
16  
17  #include <scsi/scsi_cmnd.h>
18  #include <scsi/scsi_host.h>
19  #include <uapi/scsi/cxlflash_ioctl.h>
20  
21  #include "sislite.h"
22  #include "common.h"
23  #include "vlun.h"
24  #include "superpipe.h"
25  
26  /**
27   * marshal_virt_to_resize() - translate uvirtual to resize structure
28   * @virt:	Source structure from which to translate/copy.
29   * @resize:	Destination structure for the translate/copy.
30   */
marshal_virt_to_resize(struct dk_cxlflash_uvirtual * virt,struct dk_cxlflash_resize * resize)31  static void marshal_virt_to_resize(struct dk_cxlflash_uvirtual *virt,
32  				   struct dk_cxlflash_resize *resize)
33  {
34  	resize->hdr = virt->hdr;
35  	resize->context_id = virt->context_id;
36  	resize->rsrc_handle = virt->rsrc_handle;
37  	resize->req_size = virt->lun_size;
38  	resize->last_lba = virt->last_lba;
39  }
40  
41  /**
42   * marshal_clone_to_rele() - translate clone to release structure
43   * @clone:	Source structure from which to translate/copy.
44   * @release:	Destination structure for the translate/copy.
45   */
marshal_clone_to_rele(struct dk_cxlflash_clone * clone,struct dk_cxlflash_release * release)46  static void marshal_clone_to_rele(struct dk_cxlflash_clone *clone,
47  				  struct dk_cxlflash_release *release)
48  {
49  	release->hdr = clone->hdr;
50  	release->context_id = clone->context_id_dst;
51  }
52  
53  /**
54   * ba_init() - initializes a block allocator
55   * @ba_lun:	Block allocator to initialize.
56   *
57   * Return: 0 on success, -errno on failure
58   */
ba_init(struct ba_lun * ba_lun)59  static int ba_init(struct ba_lun *ba_lun)
60  {
61  	struct ba_lun_info *bali = NULL;
62  	int lun_size_au = 0, i = 0;
63  	int last_word_underflow = 0;
64  	u64 *lam;
65  
66  	pr_debug("%s: Initializing LUN: lun_id=%016llx "
67  		 "ba_lun->lsize=%lx ba_lun->au_size=%lX\n",
68  		__func__, ba_lun->lun_id, ba_lun->lsize, ba_lun->au_size);
69  
70  	/* Calculate bit map size */
71  	lun_size_au = ba_lun->lsize / ba_lun->au_size;
72  	if (lun_size_au == 0) {
73  		pr_debug("%s: Requested LUN size of 0!\n", __func__);
74  		return -EINVAL;
75  	}
76  
77  	/* Allocate lun information container */
78  	bali = kzalloc(sizeof(struct ba_lun_info), GFP_KERNEL);
79  	if (unlikely(!bali)) {
80  		pr_err("%s: Failed to allocate lun_info lun_id=%016llx\n",
81  		       __func__, ba_lun->lun_id);
82  		return -ENOMEM;
83  	}
84  
85  	bali->total_aus = lun_size_au;
86  	bali->lun_bmap_size = lun_size_au / BITS_PER_LONG;
87  
88  	if (lun_size_au % BITS_PER_LONG)
89  		bali->lun_bmap_size++;
90  
91  	/* Allocate bitmap space */
92  	bali->lun_alloc_map = kzalloc((bali->lun_bmap_size * sizeof(u64)),
93  				      GFP_KERNEL);
94  	if (unlikely(!bali->lun_alloc_map)) {
95  		pr_err("%s: Failed to allocate lun allocation map: "
96  		       "lun_id=%016llx\n", __func__, ba_lun->lun_id);
97  		kfree(bali);
98  		return -ENOMEM;
99  	}
100  
101  	/* Initialize the bit map size and set all bits to '1' */
102  	bali->free_aun_cnt = lun_size_au;
103  
104  	for (i = 0; i < bali->lun_bmap_size; i++)
105  		bali->lun_alloc_map[i] = 0xFFFFFFFFFFFFFFFFULL;
106  
107  	/* If the last word not fully utilized, mark extra bits as allocated */
108  	last_word_underflow = (bali->lun_bmap_size * BITS_PER_LONG);
109  	last_word_underflow -= bali->free_aun_cnt;
110  	if (last_word_underflow > 0) {
111  		lam = &bali->lun_alloc_map[bali->lun_bmap_size - 1];
112  		for (i = (HIBIT - last_word_underflow + 1);
113  		     i < BITS_PER_LONG;
114  		     i++)
115  			clear_bit(i, (ulong *)lam);
116  	}
117  
118  	/* Initialize high elevator index, low/curr already at 0 from kzalloc */
119  	bali->free_high_idx = bali->lun_bmap_size;
120  
121  	/* Allocate clone map */
122  	bali->aun_clone_map = kzalloc((bali->total_aus * sizeof(u8)),
123  				      GFP_KERNEL);
124  	if (unlikely(!bali->aun_clone_map)) {
125  		pr_err("%s: Failed to allocate clone map: lun_id=%016llx\n",
126  		       __func__, ba_lun->lun_id);
127  		kfree(bali->lun_alloc_map);
128  		kfree(bali);
129  		return -ENOMEM;
130  	}
131  
132  	/* Pass the allocated LUN info as a handle to the user */
133  	ba_lun->ba_lun_handle = bali;
134  
135  	pr_debug("%s: Successfully initialized the LUN: "
136  		 "lun_id=%016llx bitmap size=%x, free_aun_cnt=%llx\n",
137  		__func__, ba_lun->lun_id, bali->lun_bmap_size,
138  		bali->free_aun_cnt);
139  	return 0;
140  }
141  
142  /**
143   * find_free_range() - locates a free bit within the block allocator
144   * @low:	First word in block allocator to start search.
145   * @high:	Last word in block allocator to search.
146   * @bali:	LUN information structure owning the block allocator to search.
147   * @bit_word:	Passes back the word in the block allocator owning the free bit.
148   *
149   * Return: The bit position within the passed back word, -1 on failure
150   */
find_free_range(u32 low,u32 high,struct ba_lun_info * bali,int * bit_word)151  static int find_free_range(u32 low,
152  			   u32 high,
153  			   struct ba_lun_info *bali, int *bit_word)
154  {
155  	int i;
156  	u64 bit_pos = -1;
157  	ulong *lam, num_bits;
158  
159  	for (i = low; i < high; i++)
160  		if (bali->lun_alloc_map[i] != 0) {
161  			lam = (ulong *)&bali->lun_alloc_map[i];
162  			num_bits = (sizeof(*lam) * BITS_PER_BYTE);
163  			bit_pos = find_first_bit(lam, num_bits);
164  
165  			pr_devel("%s: Found free bit %llu in LUN "
166  				 "map entry %016llx at bitmap index = %d\n",
167  				 __func__, bit_pos, bali->lun_alloc_map[i], i);
168  
169  			*bit_word = i;
170  			bali->free_aun_cnt--;
171  			clear_bit(bit_pos, lam);
172  			break;
173  		}
174  
175  	return bit_pos;
176  }
177  
178  /**
179   * ba_alloc() - allocates a block from the block allocator
180   * @ba_lun:	Block allocator from which to allocate a block.
181   *
182   * Return: The allocated block, -1 on failure
183   */
ba_alloc(struct ba_lun * ba_lun)184  static u64 ba_alloc(struct ba_lun *ba_lun)
185  {
186  	u64 bit_pos = -1;
187  	int bit_word = 0;
188  	struct ba_lun_info *bali = NULL;
189  
190  	bali = ba_lun->ba_lun_handle;
191  
192  	pr_debug("%s: Received block allocation request: "
193  		 "lun_id=%016llx free_aun_cnt=%llx\n",
194  		 __func__, ba_lun->lun_id, bali->free_aun_cnt);
195  
196  	if (bali->free_aun_cnt == 0) {
197  		pr_debug("%s: No space left on LUN: lun_id=%016llx\n",
198  			 __func__, ba_lun->lun_id);
199  		return -1ULL;
200  	}
201  
202  	/* Search to find a free entry, curr->high then low->curr */
203  	bit_pos = find_free_range(bali->free_curr_idx,
204  				  bali->free_high_idx, bali, &bit_word);
205  	if (bit_pos == -1) {
206  		bit_pos = find_free_range(bali->free_low_idx,
207  					  bali->free_curr_idx,
208  					  bali, &bit_word);
209  		if (bit_pos == -1) {
210  			pr_debug("%s: Could not find an allocation unit on LUN:"
211  				 " lun_id=%016llx\n", __func__, ba_lun->lun_id);
212  			return -1ULL;
213  		}
214  	}
215  
216  	/* Update the free_curr_idx */
217  	if (bit_pos == HIBIT)
218  		bali->free_curr_idx = bit_word + 1;
219  	else
220  		bali->free_curr_idx = bit_word;
221  
222  	pr_debug("%s: Allocating AU number=%llx lun_id=%016llx "
223  		 "free_aun_cnt=%llx\n", __func__,
224  		 ((bit_word * BITS_PER_LONG) + bit_pos), ba_lun->lun_id,
225  		 bali->free_aun_cnt);
226  
227  	return (u64) ((bit_word * BITS_PER_LONG) + bit_pos);
228  }
229  
230  /**
231   * validate_alloc() - validates the specified block has been allocated
232   * @bali:		LUN info owning the block allocator.
233   * @aun:		Block to validate.
234   *
235   * Return: 0 on success, -1 on failure
236   */
validate_alloc(struct ba_lun_info * bali,u64 aun)237  static int validate_alloc(struct ba_lun_info *bali, u64 aun)
238  {
239  	int idx = 0, bit_pos = 0;
240  
241  	idx = aun / BITS_PER_LONG;
242  	bit_pos = aun % BITS_PER_LONG;
243  
244  	if (test_bit(bit_pos, (ulong *)&bali->lun_alloc_map[idx]))
245  		return -1;
246  
247  	return 0;
248  }
249  
250  /**
251   * ba_free() - frees a block from the block allocator
252   * @ba_lun:	Block allocator from which to allocate a block.
253   * @to_free:	Block to free.
254   *
255   * Return: 0 on success, -1 on failure
256   */
ba_free(struct ba_lun * ba_lun,u64 to_free)257  static int ba_free(struct ba_lun *ba_lun, u64 to_free)
258  {
259  	int idx = 0, bit_pos = 0;
260  	struct ba_lun_info *bali = NULL;
261  
262  	bali = ba_lun->ba_lun_handle;
263  
264  	if (validate_alloc(bali, to_free)) {
265  		pr_debug("%s: AUN %llx is not allocated on lun_id=%016llx\n",
266  			 __func__, to_free, ba_lun->lun_id);
267  		return -1;
268  	}
269  
270  	pr_debug("%s: Received a request to free AU=%llx lun_id=%016llx "
271  		 "free_aun_cnt=%llx\n", __func__, to_free, ba_lun->lun_id,
272  		 bali->free_aun_cnt);
273  
274  	if (bali->aun_clone_map[to_free] > 0) {
275  		pr_debug("%s: AUN %llx lun_id=%016llx cloned. Clone count=%x\n",
276  			 __func__, to_free, ba_lun->lun_id,
277  			 bali->aun_clone_map[to_free]);
278  		bali->aun_clone_map[to_free]--;
279  		return 0;
280  	}
281  
282  	idx = to_free / BITS_PER_LONG;
283  	bit_pos = to_free % BITS_PER_LONG;
284  
285  	set_bit(bit_pos, (ulong *)&bali->lun_alloc_map[idx]);
286  	bali->free_aun_cnt++;
287  
288  	if (idx < bali->free_low_idx)
289  		bali->free_low_idx = idx;
290  	else if (idx > bali->free_high_idx)
291  		bali->free_high_idx = idx;
292  
293  	pr_debug("%s: Successfully freed AU bit_pos=%x bit map index=%x "
294  		 "lun_id=%016llx free_aun_cnt=%llx\n", __func__, bit_pos, idx,
295  		 ba_lun->lun_id, bali->free_aun_cnt);
296  
297  	return 0;
298  }
299  
300  /**
301   * ba_clone() - Clone a chunk of the block allocation table
302   * @ba_lun:	Block allocator from which to allocate a block.
303   * @to_clone:	Block to clone.
304   *
305   * Return: 0 on success, -1 on failure
306   */
ba_clone(struct ba_lun * ba_lun,u64 to_clone)307  static int ba_clone(struct ba_lun *ba_lun, u64 to_clone)
308  {
309  	struct ba_lun_info *bali = ba_lun->ba_lun_handle;
310  
311  	if (validate_alloc(bali, to_clone)) {
312  		pr_debug("%s: AUN=%llx not allocated on lun_id=%016llx\n",
313  			 __func__, to_clone, ba_lun->lun_id);
314  		return -1;
315  	}
316  
317  	pr_debug("%s: Received a request to clone AUN %llx on lun_id=%016llx\n",
318  		 __func__, to_clone, ba_lun->lun_id);
319  
320  	if (bali->aun_clone_map[to_clone] == MAX_AUN_CLONE_CNT) {
321  		pr_debug("%s: AUN %llx on lun_id=%016llx hit max clones already\n",
322  			 __func__, to_clone, ba_lun->lun_id);
323  		return -1;
324  	}
325  
326  	bali->aun_clone_map[to_clone]++;
327  
328  	return 0;
329  }
330  
331  /**
332   * ba_space() - returns the amount of free space left in the block allocator
333   * @ba_lun:	Block allocator.
334   *
335   * Return: Amount of free space in block allocator
336   */
ba_space(struct ba_lun * ba_lun)337  static u64 ba_space(struct ba_lun *ba_lun)
338  {
339  	struct ba_lun_info *bali = ba_lun->ba_lun_handle;
340  
341  	return bali->free_aun_cnt;
342  }
343  
344  /**
345   * cxlflash_ba_terminate() - frees resources associated with the block allocator
346   * @ba_lun:	Block allocator.
347   *
348   * Safe to call in a partially allocated state.
349   */
cxlflash_ba_terminate(struct ba_lun * ba_lun)350  void cxlflash_ba_terminate(struct ba_lun *ba_lun)
351  {
352  	struct ba_lun_info *bali = ba_lun->ba_lun_handle;
353  
354  	if (bali) {
355  		kfree(bali->aun_clone_map);
356  		kfree(bali->lun_alloc_map);
357  		kfree(bali);
358  		ba_lun->ba_lun_handle = NULL;
359  	}
360  }
361  
362  /**
363   * init_vlun() - initializes a LUN for virtual use
364   * @lli:	LUN information structure that owns the block allocator.
365   *
366   * Return: 0 on success, -errno on failure
367   */
init_vlun(struct llun_info * lli)368  static int init_vlun(struct llun_info *lli)
369  {
370  	int rc = 0;
371  	struct glun_info *gli = lli->parent;
372  	struct blka *blka = &gli->blka;
373  
374  	memset(blka, 0, sizeof(*blka));
375  	mutex_init(&blka->mutex);
376  
377  	/* LUN IDs are unique per port, save the index instead */
378  	blka->ba_lun.lun_id = lli->lun_index;
379  	blka->ba_lun.lsize = gli->max_lba + 1;
380  	blka->ba_lun.lba_size = gli->blk_len;
381  
382  	blka->ba_lun.au_size = MC_CHUNK_SIZE;
383  	blka->nchunk = blka->ba_lun.lsize / MC_CHUNK_SIZE;
384  
385  	rc = ba_init(&blka->ba_lun);
386  	if (unlikely(rc))
387  		pr_debug("%s: cannot init block_alloc, rc=%d\n", __func__, rc);
388  
389  	pr_debug("%s: returning rc=%d lli=%p\n", __func__, rc, lli);
390  	return rc;
391  }
392  
393  /**
394   * write_same16() - sends a SCSI WRITE_SAME16 (0) command to specified LUN
395   * @sdev:	SCSI device associated with LUN.
396   * @lba:	Logical block address to start write same.
397   * @nblks:	Number of logical blocks to write same.
398   *
399   * The SCSI WRITE_SAME16 can take quite a while to complete. Should an EEH occur
400   * while in scsi_execute_cmd(), the EEH handler will attempt to recover. As
401   * part of the recovery, the handler drains all currently running ioctls,
402   * waiting until they have completed before proceeding with a reset. As this
403   * routine is used on the ioctl path, this can create a condition where the
404   * EEH handler becomes stuck, infinitely waiting for this ioctl thread. To
405   * avoid this behavior, temporarily unmark this thread as an ioctl thread by
406   * releasing the ioctl read semaphore. This will allow the EEH handler to
407   * proceed with a recovery while this thread is still running. Once the
408   * scsi_execute_cmd() returns, reacquire the ioctl read semaphore and check the
409   * adapter state in case it changed while inside of scsi_execute_cmd(). The
410   * state check will wait if the adapter is still being recovered or return a
411   * failure if the recovery failed. In the event that the adapter reset failed,
412   * simply return the failure as the ioctl would be unable to continue.
413   *
414   * Note that the above puts a requirement on this routine to only be called on
415   * an ioctl thread.
416   *
417   * Return: 0 on success, -errno on failure
418   */
write_same16(struct scsi_device * sdev,u64 lba,u32 nblks)419  static int write_same16(struct scsi_device *sdev,
420  			u64 lba,
421  			u32 nblks)
422  {
423  	u8 *cmd_buf = NULL;
424  	u8 *scsi_cmd = NULL;
425  	int rc = 0;
426  	int result = 0;
427  	u64 offset = lba;
428  	int left = nblks;
429  	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
430  	struct device *dev = &cfg->dev->dev;
431  	const u32 s = ilog2(sdev->sector_size) - 9;
432  	const u32 to = sdev->request_queue->rq_timeout;
433  	const u32 ws_limit =
434  		sdev->request_queue->limits.max_write_zeroes_sectors >> s;
435  
436  	cmd_buf = kzalloc(CMD_BUFSIZE, GFP_KERNEL);
437  	scsi_cmd = kzalloc(MAX_COMMAND_SIZE, GFP_KERNEL);
438  	if (unlikely(!cmd_buf || !scsi_cmd)) {
439  		rc = -ENOMEM;
440  		goto out;
441  	}
442  
443  	while (left > 0) {
444  
445  		scsi_cmd[0] = WRITE_SAME_16;
446  		scsi_cmd[1] = cfg->ws_unmap ? 0x8 : 0;
447  		put_unaligned_be64(offset, &scsi_cmd[2]);
448  		put_unaligned_be32(ws_limit < left ? ws_limit : left,
449  				   &scsi_cmd[10]);
450  
451  		/* Drop the ioctl read semaphore across lengthy call */
452  		up_read(&cfg->ioctl_rwsem);
453  		result = scsi_execute_cmd(sdev, scsi_cmd, REQ_OP_DRV_OUT,
454  					  cmd_buf, CMD_BUFSIZE, to,
455  					  CMD_RETRIES, NULL);
456  		down_read(&cfg->ioctl_rwsem);
457  		rc = check_state(cfg);
458  		if (rc) {
459  			dev_err(dev, "%s: Failed state result=%08x\n",
460  				__func__, result);
461  			rc = -ENODEV;
462  			goto out;
463  		}
464  
465  		if (result) {
466  			dev_err_ratelimited(dev, "%s: command failed for "
467  					    "offset=%lld result=%08x\n",
468  					    __func__, offset, result);
469  			rc = -EIO;
470  			goto out;
471  		}
472  		left -= ws_limit;
473  		offset += ws_limit;
474  	}
475  
476  out:
477  	kfree(cmd_buf);
478  	kfree(scsi_cmd);
479  	dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
480  	return rc;
481  }
482  
483  /**
484   * grow_lxt() - expands the translation table associated with the specified RHTE
485   * @afu:	AFU associated with the host.
486   * @sdev:	SCSI device associated with LUN.
487   * @ctxid:	Context ID of context owning the RHTE.
488   * @rhndl:	Resource handle associated with the RHTE.
489   * @rhte:	Resource handle entry (RHTE).
490   * @new_size:	Number of translation entries associated with RHTE.
491   *
492   * By design, this routine employs a 'best attempt' allocation and will
493   * truncate the requested size down if there is not sufficient space in
494   * the block allocator to satisfy the request but there does exist some
495   * amount of space. The user is made aware of this by returning the size
496   * allocated.
497   *
498   * Return: 0 on success, -errno on failure
499   */
grow_lxt(struct afu * afu,struct scsi_device * sdev,ctx_hndl_t ctxid,res_hndl_t rhndl,struct sisl_rht_entry * rhte,u64 * new_size)500  static int grow_lxt(struct afu *afu,
501  		    struct scsi_device *sdev,
502  		    ctx_hndl_t ctxid,
503  		    res_hndl_t rhndl,
504  		    struct sisl_rht_entry *rhte,
505  		    u64 *new_size)
506  {
507  	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
508  	struct device *dev = &cfg->dev->dev;
509  	struct sisl_lxt_entry *lxt = NULL, *lxt_old = NULL;
510  	struct llun_info *lli = sdev->hostdata;
511  	struct glun_info *gli = lli->parent;
512  	struct blka *blka = &gli->blka;
513  	u32 av_size;
514  	u32 ngrps, ngrps_old;
515  	u64 aun;		/* chunk# allocated by block allocator */
516  	u64 delta = *new_size - rhte->lxt_cnt;
517  	u64 my_new_size;
518  	int i, rc = 0;
519  
520  	/*
521  	 * Check what is available in the block allocator before re-allocating
522  	 * LXT array. This is done up front under the mutex which must not be
523  	 * released until after allocation is complete.
524  	 */
525  	mutex_lock(&blka->mutex);
526  	av_size = ba_space(&blka->ba_lun);
527  	if (unlikely(av_size <= 0)) {
528  		dev_dbg(dev, "%s: ba_space error av_size=%d\n",
529  			__func__, av_size);
530  		mutex_unlock(&blka->mutex);
531  		rc = -ENOSPC;
532  		goto out;
533  	}
534  
535  	if (av_size < delta)
536  		delta = av_size;
537  
538  	lxt_old = rhte->lxt_start;
539  	ngrps_old = LXT_NUM_GROUPS(rhte->lxt_cnt);
540  	ngrps = LXT_NUM_GROUPS(rhte->lxt_cnt + delta);
541  
542  	if (ngrps != ngrps_old) {
543  		/* reallocate to fit new size */
544  		lxt = kzalloc((sizeof(*lxt) * LXT_GROUP_SIZE * ngrps),
545  			      GFP_KERNEL);
546  		if (unlikely(!lxt)) {
547  			mutex_unlock(&blka->mutex);
548  			rc = -ENOMEM;
549  			goto out;
550  		}
551  
552  		/* copy over all old entries */
553  		memcpy(lxt, lxt_old, (sizeof(*lxt) * rhte->lxt_cnt));
554  	} else
555  		lxt = lxt_old;
556  
557  	/* nothing can fail from now on */
558  	my_new_size = rhte->lxt_cnt + delta;
559  
560  	/* add new entries to the end */
561  	for (i = rhte->lxt_cnt; i < my_new_size; i++) {
562  		/*
563  		 * Due to the earlier check of available space, ba_alloc
564  		 * cannot fail here. If it did due to internal error,
565  		 * leave a rlba_base of -1u which will likely be a
566  		 * invalid LUN (too large).
567  		 */
568  		aun = ba_alloc(&blka->ba_lun);
569  		if ((aun == -1ULL) || (aun >= blka->nchunk))
570  			dev_dbg(dev, "%s: ba_alloc error allocated chunk=%llu "
571  				"max=%llu\n", __func__, aun, blka->nchunk - 1);
572  
573  		/* select both ports, use r/w perms from RHT */
574  		lxt[i].rlba_base = ((aun << MC_CHUNK_SHIFT) |
575  				    (lli->lun_index << LXT_LUNIDX_SHIFT) |
576  				    (RHT_PERM_RW << LXT_PERM_SHIFT |
577  				     lli->port_sel));
578  	}
579  
580  	mutex_unlock(&blka->mutex);
581  
582  	/*
583  	 * The following sequence is prescribed in the SISlite spec
584  	 * for syncing up with the AFU when adding LXT entries.
585  	 */
586  	dma_wmb(); /* Make LXT updates are visible */
587  
588  	rhte->lxt_start = lxt;
589  	dma_wmb(); /* Make RHT entry's LXT table update visible */
590  
591  	rhte->lxt_cnt = my_new_size;
592  	dma_wmb(); /* Make RHT entry's LXT table size update visible */
593  
594  	rc = cxlflash_afu_sync(afu, ctxid, rhndl, AFU_LW_SYNC);
595  	if (unlikely(rc))
596  		rc = -EAGAIN;
597  
598  	/* free old lxt if reallocated */
599  	if (lxt != lxt_old)
600  		kfree(lxt_old);
601  	*new_size = my_new_size;
602  out:
603  	dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
604  	return rc;
605  }
606  
607  /**
608   * shrink_lxt() - reduces translation table associated with the specified RHTE
609   * @afu:	AFU associated with the host.
610   * @sdev:	SCSI device associated with LUN.
611   * @rhndl:	Resource handle associated with the RHTE.
612   * @rhte:	Resource handle entry (RHTE).
613   * @ctxi:	Context owning resources.
614   * @new_size:	Number of translation entries associated with RHTE.
615   *
616   * Return: 0 on success, -errno on failure
617   */
shrink_lxt(struct afu * afu,struct scsi_device * sdev,res_hndl_t rhndl,struct sisl_rht_entry * rhte,struct ctx_info * ctxi,u64 * new_size)618  static int shrink_lxt(struct afu *afu,
619  		      struct scsi_device *sdev,
620  		      res_hndl_t rhndl,
621  		      struct sisl_rht_entry *rhte,
622  		      struct ctx_info *ctxi,
623  		      u64 *new_size)
624  {
625  	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
626  	struct device *dev = &cfg->dev->dev;
627  	struct sisl_lxt_entry *lxt, *lxt_old;
628  	struct llun_info *lli = sdev->hostdata;
629  	struct glun_info *gli = lli->parent;
630  	struct blka *blka = &gli->blka;
631  	ctx_hndl_t ctxid = DECODE_CTXID(ctxi->ctxid);
632  	bool needs_ws = ctxi->rht_needs_ws[rhndl];
633  	bool needs_sync = !ctxi->err_recovery_active;
634  	u32 ngrps, ngrps_old;
635  	u64 aun;		/* chunk# allocated by block allocator */
636  	u64 delta = rhte->lxt_cnt - *new_size;
637  	u64 my_new_size;
638  	int i, rc = 0;
639  
640  	lxt_old = rhte->lxt_start;
641  	ngrps_old = LXT_NUM_GROUPS(rhte->lxt_cnt);
642  	ngrps = LXT_NUM_GROUPS(rhte->lxt_cnt - delta);
643  
644  	if (ngrps != ngrps_old) {
645  		/* Reallocate to fit new size unless new size is 0 */
646  		if (ngrps) {
647  			lxt = kzalloc((sizeof(*lxt) * LXT_GROUP_SIZE * ngrps),
648  				      GFP_KERNEL);
649  			if (unlikely(!lxt)) {
650  				rc = -ENOMEM;
651  				goto out;
652  			}
653  
654  			/* Copy over old entries that will remain */
655  			memcpy(lxt, lxt_old,
656  			       (sizeof(*lxt) * (rhte->lxt_cnt - delta)));
657  		} else
658  			lxt = NULL;
659  	} else
660  		lxt = lxt_old;
661  
662  	/* Nothing can fail from now on */
663  	my_new_size = rhte->lxt_cnt - delta;
664  
665  	/*
666  	 * The following sequence is prescribed in the SISlite spec
667  	 * for syncing up with the AFU when removing LXT entries.
668  	 */
669  	rhte->lxt_cnt = my_new_size;
670  	dma_wmb(); /* Make RHT entry's LXT table size update visible */
671  
672  	rhte->lxt_start = lxt;
673  	dma_wmb(); /* Make RHT entry's LXT table update visible */
674  
675  	if (needs_sync) {
676  		rc = cxlflash_afu_sync(afu, ctxid, rhndl, AFU_HW_SYNC);
677  		if (unlikely(rc))
678  			rc = -EAGAIN;
679  	}
680  
681  	if (needs_ws) {
682  		/*
683  		 * Mark the context as unavailable, so that we can release
684  		 * the mutex safely.
685  		 */
686  		ctxi->unavail = true;
687  		mutex_unlock(&ctxi->mutex);
688  	}
689  
690  	/* Free LBAs allocated to freed chunks */
691  	mutex_lock(&blka->mutex);
692  	for (i = delta - 1; i >= 0; i--) {
693  		aun = lxt_old[my_new_size + i].rlba_base >> MC_CHUNK_SHIFT;
694  		if (needs_ws)
695  			write_same16(sdev, aun, MC_CHUNK_SIZE);
696  		ba_free(&blka->ba_lun, aun);
697  	}
698  	mutex_unlock(&blka->mutex);
699  
700  	if (needs_ws) {
701  		/* Make the context visible again */
702  		mutex_lock(&ctxi->mutex);
703  		ctxi->unavail = false;
704  	}
705  
706  	/* Free old lxt if reallocated */
707  	if (lxt != lxt_old)
708  		kfree(lxt_old);
709  	*new_size = my_new_size;
710  out:
711  	dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
712  	return rc;
713  }
714  
715  /**
716   * _cxlflash_vlun_resize() - changes the size of a virtual LUN
717   * @sdev:	SCSI device associated with LUN owning virtual LUN.
718   * @ctxi:	Context owning resources.
719   * @resize:	Resize ioctl data structure.
720   *
721   * On successful return, the user is informed of the new size (in blocks)
722   * of the virtual LUN in last LBA format. When the size of the virtual
723   * LUN is zero, the last LBA is reflected as -1. See comment in the
724   * prologue for _cxlflash_disk_release() regarding AFU syncs and contexts
725   * on the error recovery list.
726   *
727   * Return: 0 on success, -errno on failure
728   */
_cxlflash_vlun_resize(struct scsi_device * sdev,struct ctx_info * ctxi,struct dk_cxlflash_resize * resize)729  int _cxlflash_vlun_resize(struct scsi_device *sdev,
730  			  struct ctx_info *ctxi,
731  			  struct dk_cxlflash_resize *resize)
732  {
733  	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
734  	struct device *dev = &cfg->dev->dev;
735  	struct llun_info *lli = sdev->hostdata;
736  	struct glun_info *gli = lli->parent;
737  	struct afu *afu = cfg->afu;
738  	bool put_ctx = false;
739  
740  	res_hndl_t rhndl = resize->rsrc_handle;
741  	u64 new_size;
742  	u64 nsectors;
743  	u64 ctxid = DECODE_CTXID(resize->context_id),
744  	    rctxid = resize->context_id;
745  
746  	struct sisl_rht_entry *rhte;
747  
748  	int rc = 0;
749  
750  	/*
751  	 * The requested size (req_size) is always assumed to be in 4k blocks,
752  	 * so we have to convert it here from 4k to chunk size.
753  	 */
754  	nsectors = (resize->req_size * CXLFLASH_BLOCK_SIZE) / gli->blk_len;
755  	new_size = DIV_ROUND_UP(nsectors, MC_CHUNK_SIZE);
756  
757  	dev_dbg(dev, "%s: ctxid=%llu rhndl=%llu req_size=%llu new_size=%llu\n",
758  		__func__, ctxid, resize->rsrc_handle, resize->req_size,
759  		new_size);
760  
761  	if (unlikely(gli->mode != MODE_VIRTUAL)) {
762  		dev_dbg(dev, "%s: LUN mode does not support resize mode=%d\n",
763  			__func__, gli->mode);
764  		rc = -EINVAL;
765  		goto out;
766  
767  	}
768  
769  	if (!ctxi) {
770  		ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
771  		if (unlikely(!ctxi)) {
772  			dev_dbg(dev, "%s: Bad context ctxid=%llu\n",
773  				__func__, ctxid);
774  			rc = -EINVAL;
775  			goto out;
776  		}
777  
778  		put_ctx = true;
779  	}
780  
781  	rhte = get_rhte(ctxi, rhndl, lli);
782  	if (unlikely(!rhte)) {
783  		dev_dbg(dev, "%s: Bad resource handle rhndl=%u\n",
784  			__func__, rhndl);
785  		rc = -EINVAL;
786  		goto out;
787  	}
788  
789  	if (new_size > rhte->lxt_cnt)
790  		rc = grow_lxt(afu, sdev, ctxid, rhndl, rhte, &new_size);
791  	else if (new_size < rhte->lxt_cnt)
792  		rc = shrink_lxt(afu, sdev, rhndl, rhte, ctxi, &new_size);
793  	else {
794  		/*
795  		 * Rare case where there is already sufficient space, just
796  		 * need to perform a translation sync with the AFU. This
797  		 * scenario likely follows a previous sync failure during
798  		 * a resize operation. Accordingly, perform the heavyweight
799  		 * form of translation sync as it is unknown which type of
800  		 * resize failed previously.
801  		 */
802  		rc = cxlflash_afu_sync(afu, ctxid, rhndl, AFU_HW_SYNC);
803  		if (unlikely(rc)) {
804  			rc = -EAGAIN;
805  			goto out;
806  		}
807  	}
808  
809  	resize->hdr.return_flags = 0;
810  	resize->last_lba = (new_size * MC_CHUNK_SIZE * gli->blk_len);
811  	resize->last_lba /= CXLFLASH_BLOCK_SIZE;
812  	resize->last_lba--;
813  
814  out:
815  	if (put_ctx)
816  		put_context(ctxi);
817  	dev_dbg(dev, "%s: resized to %llu returning rc=%d\n",
818  		__func__, resize->last_lba, rc);
819  	return rc;
820  }
821  
cxlflash_vlun_resize(struct scsi_device * sdev,struct dk_cxlflash_resize * resize)822  int cxlflash_vlun_resize(struct scsi_device *sdev,
823  			 struct dk_cxlflash_resize *resize)
824  {
825  	return _cxlflash_vlun_resize(sdev, NULL, resize);
826  }
827  
828  /**
829   * cxlflash_restore_luntable() - Restore LUN table to prior state
830   * @cfg:	Internal structure associated with the host.
831   */
cxlflash_restore_luntable(struct cxlflash_cfg * cfg)832  void cxlflash_restore_luntable(struct cxlflash_cfg *cfg)
833  {
834  	struct llun_info *lli, *temp;
835  	u32 lind;
836  	int k;
837  	struct device *dev = &cfg->dev->dev;
838  	__be64 __iomem *fc_port_luns;
839  
840  	mutex_lock(&global.mutex);
841  
842  	list_for_each_entry_safe(lli, temp, &cfg->lluns, list) {
843  		if (!lli->in_table)
844  			continue;
845  
846  		lind = lli->lun_index;
847  		dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n", __func__, lind);
848  
849  		for (k = 0; k < cfg->num_fc_ports; k++)
850  			if (lli->port_sel & (1 << k)) {
851  				fc_port_luns = get_fc_port_luns(cfg, k);
852  				writeq_be(lli->lun_id[k], &fc_port_luns[lind]);
853  				dev_dbg(dev, "\t%d=%llx\n", k, lli->lun_id[k]);
854  			}
855  	}
856  
857  	mutex_unlock(&global.mutex);
858  }
859  
860  /**
861   * get_num_ports() - compute number of ports from port selection mask
862   * @psm:	Port selection mask.
863   *
864   * Return: Population count of port selection mask
865   */
get_num_ports(u32 psm)866  static inline u8 get_num_ports(u32 psm)
867  {
868  	static const u8 bits[16] = { 0, 1, 1, 2, 1, 2, 2, 3,
869  				     1, 2, 2, 3, 2, 3, 3, 4 };
870  
871  	return bits[psm & 0xf];
872  }
873  
874  /**
875   * init_luntable() - write an entry in the LUN table
876   * @cfg:	Internal structure associated with the host.
877   * @lli:	Per adapter LUN information structure.
878   *
879   * On successful return, a LUN table entry is created:
880   *	- at the top for LUNs visible on multiple ports.
881   *	- at the bottom for LUNs visible only on one port.
882   *
883   * Return: 0 on success, -errno on failure
884   */
init_luntable(struct cxlflash_cfg * cfg,struct llun_info * lli)885  static int init_luntable(struct cxlflash_cfg *cfg, struct llun_info *lli)
886  {
887  	u32 chan;
888  	u32 lind;
889  	u32 nports;
890  	int rc = 0;
891  	int k;
892  	struct device *dev = &cfg->dev->dev;
893  	__be64 __iomem *fc_port_luns;
894  
895  	mutex_lock(&global.mutex);
896  
897  	if (lli->in_table)
898  		goto out;
899  
900  	nports = get_num_ports(lli->port_sel);
901  	if (nports == 0 || nports > cfg->num_fc_ports) {
902  		WARN(1, "Unsupported port configuration nports=%u", nports);
903  		rc = -EIO;
904  		goto out;
905  	}
906  
907  	if (nports > 1) {
908  		/*
909  		 * When LUN is visible from multiple ports, we will put
910  		 * it in the top half of the LUN table.
911  		 */
912  		for (k = 0; k < cfg->num_fc_ports; k++) {
913  			if (!(lli->port_sel & (1 << k)))
914  				continue;
915  
916  			if (cfg->promote_lun_index == cfg->last_lun_index[k]) {
917  				rc = -ENOSPC;
918  				goto out;
919  			}
920  		}
921  
922  		lind = lli->lun_index = cfg->promote_lun_index;
923  		dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n", __func__, lind);
924  
925  		for (k = 0; k < cfg->num_fc_ports; k++) {
926  			if (!(lli->port_sel & (1 << k)))
927  				continue;
928  
929  			fc_port_luns = get_fc_port_luns(cfg, k);
930  			writeq_be(lli->lun_id[k], &fc_port_luns[lind]);
931  			dev_dbg(dev, "\t%d=%llx\n", k, lli->lun_id[k]);
932  		}
933  
934  		cfg->promote_lun_index++;
935  	} else {
936  		/*
937  		 * When LUN is visible only from one port, we will put
938  		 * it in the bottom half of the LUN table.
939  		 */
940  		chan = PORTMASK2CHAN(lli->port_sel);
941  		if (cfg->promote_lun_index == cfg->last_lun_index[chan]) {
942  			rc = -ENOSPC;
943  			goto out;
944  		}
945  
946  		lind = lli->lun_index = cfg->last_lun_index[chan];
947  		fc_port_luns = get_fc_port_luns(cfg, chan);
948  		writeq_be(lli->lun_id[chan], &fc_port_luns[lind]);
949  		cfg->last_lun_index[chan]--;
950  		dev_dbg(dev, "%s: Virtual LUNs on slot %d:\n\t%d=%llx\n",
951  			__func__, lind, chan, lli->lun_id[chan]);
952  	}
953  
954  	lli->in_table = true;
955  out:
956  	mutex_unlock(&global.mutex);
957  	dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
958  	return rc;
959  }
960  
961  /**
962   * cxlflash_disk_virtual_open() - open a virtual disk of specified size
963   * @sdev:	SCSI device associated with LUN owning virtual LUN.
964   * @arg:	UVirtual ioctl data structure.
965   *
966   * On successful return, the user is informed of the resource handle
967   * to be used to identify the virtual LUN and the size (in blocks) of
968   * the virtual LUN in last LBA format. When the size of the virtual LUN
969   * is zero, the last LBA is reflected as -1.
970   *
971   * Return: 0 on success, -errno on failure
972   */
cxlflash_disk_virtual_open(struct scsi_device * sdev,void * arg)973  int cxlflash_disk_virtual_open(struct scsi_device *sdev, void *arg)
974  {
975  	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
976  	struct device *dev = &cfg->dev->dev;
977  	struct llun_info *lli = sdev->hostdata;
978  	struct glun_info *gli = lli->parent;
979  
980  	struct dk_cxlflash_uvirtual *virt = (struct dk_cxlflash_uvirtual *)arg;
981  	struct dk_cxlflash_resize resize;
982  
983  	u64 ctxid = DECODE_CTXID(virt->context_id),
984  	    rctxid = virt->context_id;
985  	u64 lun_size = virt->lun_size;
986  	u64 last_lba = 0;
987  	u64 rsrc_handle = -1;
988  
989  	int rc = 0;
990  
991  	struct ctx_info *ctxi = NULL;
992  	struct sisl_rht_entry *rhte = NULL;
993  
994  	dev_dbg(dev, "%s: ctxid=%llu ls=%llu\n", __func__, ctxid, lun_size);
995  
996  	/* Setup the LUNs block allocator on first call */
997  	mutex_lock(&gli->mutex);
998  	if (gli->mode == MODE_NONE) {
999  		rc = init_vlun(lli);
1000  		if (rc) {
1001  			dev_err(dev, "%s: init_vlun failed rc=%d\n",
1002  				__func__, rc);
1003  			rc = -ENOMEM;
1004  			goto err0;
1005  		}
1006  	}
1007  
1008  	rc = cxlflash_lun_attach(gli, MODE_VIRTUAL, true);
1009  	if (unlikely(rc)) {
1010  		dev_err(dev, "%s: Failed attach to LUN (VIRTUAL)\n", __func__);
1011  		goto err0;
1012  	}
1013  	mutex_unlock(&gli->mutex);
1014  
1015  	rc = init_luntable(cfg, lli);
1016  	if (rc) {
1017  		dev_err(dev, "%s: init_luntable failed rc=%d\n", __func__, rc);
1018  		goto err1;
1019  	}
1020  
1021  	ctxi = get_context(cfg, rctxid, lli, 0);
1022  	if (unlikely(!ctxi)) {
1023  		dev_err(dev, "%s: Bad context ctxid=%llu\n", __func__, ctxid);
1024  		rc = -EINVAL;
1025  		goto err1;
1026  	}
1027  
1028  	rhte = rhte_checkout(ctxi, lli);
1029  	if (unlikely(!rhte)) {
1030  		dev_err(dev, "%s: too many opens ctxid=%llu\n",
1031  			__func__, ctxid);
1032  		rc = -EMFILE;	/* too many opens  */
1033  		goto err1;
1034  	}
1035  
1036  	rsrc_handle = (rhte - ctxi->rht_start);
1037  
1038  	/* Populate RHT format 0 */
1039  	rhte->nmask = MC_RHT_NMASK;
1040  	rhte->fp = SISL_RHT_FP(0U, ctxi->rht_perms);
1041  
1042  	/* Resize even if requested size is 0 */
1043  	marshal_virt_to_resize(virt, &resize);
1044  	resize.rsrc_handle = rsrc_handle;
1045  	rc = _cxlflash_vlun_resize(sdev, ctxi, &resize);
1046  	if (rc) {
1047  		dev_err(dev, "%s: resize failed rc=%d\n", __func__, rc);
1048  		goto err2;
1049  	}
1050  	last_lba = resize.last_lba;
1051  
1052  	if (virt->hdr.flags & DK_CXLFLASH_UVIRTUAL_NEED_WRITE_SAME)
1053  		ctxi->rht_needs_ws[rsrc_handle] = true;
1054  
1055  	virt->hdr.return_flags = 0;
1056  	virt->last_lba = last_lba;
1057  	virt->rsrc_handle = rsrc_handle;
1058  
1059  	if (get_num_ports(lli->port_sel) > 1)
1060  		virt->hdr.return_flags |= DK_CXLFLASH_ALL_PORTS_ACTIVE;
1061  out:
1062  	if (likely(ctxi))
1063  		put_context(ctxi);
1064  	dev_dbg(dev, "%s: returning handle=%llu rc=%d llba=%llu\n",
1065  		__func__, rsrc_handle, rc, last_lba);
1066  	return rc;
1067  
1068  err2:
1069  	rhte_checkin(ctxi, rhte);
1070  err1:
1071  	cxlflash_lun_detach(gli);
1072  	goto out;
1073  err0:
1074  	/* Special common cleanup prior to successful LUN attach */
1075  	cxlflash_ba_terminate(&gli->blka.ba_lun);
1076  	mutex_unlock(&gli->mutex);
1077  	goto out;
1078  }
1079  
1080  /**
1081   * clone_lxt() - copies translation tables from source to destination RHTE
1082   * @afu:	AFU associated with the host.
1083   * @blka:	Block allocator associated with LUN.
1084   * @ctxid:	Context ID of context owning the RHTE.
1085   * @rhndl:	Resource handle associated with the RHTE.
1086   * @rhte:	Destination resource handle entry (RHTE).
1087   * @rhte_src:	Source resource handle entry (RHTE).
1088   *
1089   * Return: 0 on success, -errno on failure
1090   */
clone_lxt(struct afu * afu,struct blka * blka,ctx_hndl_t ctxid,res_hndl_t rhndl,struct sisl_rht_entry * rhte,struct sisl_rht_entry * rhte_src)1091  static int clone_lxt(struct afu *afu,
1092  		     struct blka *blka,
1093  		     ctx_hndl_t ctxid,
1094  		     res_hndl_t rhndl,
1095  		     struct sisl_rht_entry *rhte,
1096  		     struct sisl_rht_entry *rhte_src)
1097  {
1098  	struct cxlflash_cfg *cfg = afu->parent;
1099  	struct device *dev = &cfg->dev->dev;
1100  	struct sisl_lxt_entry *lxt = NULL;
1101  	bool locked = false;
1102  	u32 ngrps;
1103  	u64 aun;		/* chunk# allocated by block allocator */
1104  	int j;
1105  	int i = 0;
1106  	int rc = 0;
1107  
1108  	ngrps = LXT_NUM_GROUPS(rhte_src->lxt_cnt);
1109  
1110  	if (ngrps) {
1111  		/* allocate new LXTs for clone */
1112  		lxt = kzalloc((sizeof(*lxt) * LXT_GROUP_SIZE * ngrps),
1113  				GFP_KERNEL);
1114  		if (unlikely(!lxt)) {
1115  			rc = -ENOMEM;
1116  			goto out;
1117  		}
1118  
1119  		/* copy over */
1120  		memcpy(lxt, rhte_src->lxt_start,
1121  		       (sizeof(*lxt) * rhte_src->lxt_cnt));
1122  
1123  		/* clone the LBAs in block allocator via ref_cnt, note that the
1124  		 * block allocator mutex must be held until it is established
1125  		 * that this routine will complete without the need for a
1126  		 * cleanup.
1127  		 */
1128  		mutex_lock(&blka->mutex);
1129  		locked = true;
1130  		for (i = 0; i < rhte_src->lxt_cnt; i++) {
1131  			aun = (lxt[i].rlba_base >> MC_CHUNK_SHIFT);
1132  			if (ba_clone(&blka->ba_lun, aun) == -1ULL) {
1133  				rc = -EIO;
1134  				goto err;
1135  			}
1136  		}
1137  	}
1138  
1139  	/*
1140  	 * The following sequence is prescribed in the SISlite spec
1141  	 * for syncing up with the AFU when adding LXT entries.
1142  	 */
1143  	dma_wmb(); /* Make LXT updates are visible */
1144  
1145  	rhte->lxt_start = lxt;
1146  	dma_wmb(); /* Make RHT entry's LXT table update visible */
1147  
1148  	rhte->lxt_cnt = rhte_src->lxt_cnt;
1149  	dma_wmb(); /* Make RHT entry's LXT table size update visible */
1150  
1151  	rc = cxlflash_afu_sync(afu, ctxid, rhndl, AFU_LW_SYNC);
1152  	if (unlikely(rc)) {
1153  		rc = -EAGAIN;
1154  		goto err2;
1155  	}
1156  
1157  out:
1158  	if (locked)
1159  		mutex_unlock(&blka->mutex);
1160  	dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
1161  	return rc;
1162  err2:
1163  	/* Reset the RHTE */
1164  	rhte->lxt_cnt = 0;
1165  	dma_wmb();
1166  	rhte->lxt_start = NULL;
1167  	dma_wmb();
1168  err:
1169  	/* free the clones already made */
1170  	for (j = 0; j < i; j++) {
1171  		aun = (lxt[j].rlba_base >> MC_CHUNK_SHIFT);
1172  		ba_free(&blka->ba_lun, aun);
1173  	}
1174  	kfree(lxt);
1175  	goto out;
1176  }
1177  
1178  /**
1179   * cxlflash_disk_clone() - clone a context by making snapshot of another
1180   * @sdev:	SCSI device associated with LUN owning virtual LUN.
1181   * @clone:	Clone ioctl data structure.
1182   *
1183   * This routine effectively performs cxlflash_disk_open operation for each
1184   * in-use virtual resource in the source context. Note that the destination
1185   * context must be in pristine state and cannot have any resource handles
1186   * open at the time of the clone.
1187   *
1188   * Return: 0 on success, -errno on failure
1189   */
cxlflash_disk_clone(struct scsi_device * sdev,struct dk_cxlflash_clone * clone)1190  int cxlflash_disk_clone(struct scsi_device *sdev,
1191  			struct dk_cxlflash_clone *clone)
1192  {
1193  	struct cxlflash_cfg *cfg = shost_priv(sdev->host);
1194  	struct device *dev = &cfg->dev->dev;
1195  	struct llun_info *lli = sdev->hostdata;
1196  	struct glun_info *gli = lli->parent;
1197  	struct blka *blka = &gli->blka;
1198  	struct afu *afu = cfg->afu;
1199  	struct dk_cxlflash_release release = { { 0 }, 0 };
1200  
1201  	struct ctx_info *ctxi_src = NULL,
1202  			*ctxi_dst = NULL;
1203  	struct lun_access *lun_access_src, *lun_access_dst;
1204  	u32 perms;
1205  	u64 ctxid_src = DECODE_CTXID(clone->context_id_src),
1206  	    ctxid_dst = DECODE_CTXID(clone->context_id_dst),
1207  	    rctxid_src = clone->context_id_src,
1208  	    rctxid_dst = clone->context_id_dst;
1209  	int i, j;
1210  	int rc = 0;
1211  	bool found;
1212  	LIST_HEAD(sidecar);
1213  
1214  	dev_dbg(dev, "%s: ctxid_src=%llu ctxid_dst=%llu\n",
1215  		__func__, ctxid_src, ctxid_dst);
1216  
1217  	/* Do not clone yourself */
1218  	if (unlikely(rctxid_src == rctxid_dst)) {
1219  		rc = -EINVAL;
1220  		goto out;
1221  	}
1222  
1223  	if (unlikely(gli->mode != MODE_VIRTUAL)) {
1224  		rc = -EINVAL;
1225  		dev_dbg(dev, "%s: Only supported on virtual LUNs mode=%u\n",
1226  			__func__, gli->mode);
1227  		goto out;
1228  	}
1229  
1230  	ctxi_src = get_context(cfg, rctxid_src, lli, CTX_CTRL_CLONE);
1231  	ctxi_dst = get_context(cfg, rctxid_dst, lli, 0);
1232  	if (unlikely(!ctxi_src || !ctxi_dst)) {
1233  		dev_dbg(dev, "%s: Bad context ctxid_src=%llu ctxid_dst=%llu\n",
1234  			__func__, ctxid_src, ctxid_dst);
1235  		rc = -EINVAL;
1236  		goto out;
1237  	}
1238  
1239  	/* Verify there is no open resource handle in the destination context */
1240  	for (i = 0; i < MAX_RHT_PER_CONTEXT; i++)
1241  		if (ctxi_dst->rht_start[i].nmask != 0) {
1242  			rc = -EINVAL;
1243  			goto out;
1244  		}
1245  
1246  	/* Clone LUN access list */
1247  	list_for_each_entry(lun_access_src, &ctxi_src->luns, list) {
1248  		found = false;
1249  		list_for_each_entry(lun_access_dst, &ctxi_dst->luns, list)
1250  			if (lun_access_dst->sdev == lun_access_src->sdev) {
1251  				found = true;
1252  				break;
1253  			}
1254  
1255  		if (!found) {
1256  			lun_access_dst = kzalloc(sizeof(*lun_access_dst),
1257  						 GFP_KERNEL);
1258  			if (unlikely(!lun_access_dst)) {
1259  				dev_err(dev, "%s: lun_access allocation fail\n",
1260  					__func__);
1261  				rc = -ENOMEM;
1262  				goto out;
1263  			}
1264  
1265  			*lun_access_dst = *lun_access_src;
1266  			list_add(&lun_access_dst->list, &sidecar);
1267  		}
1268  	}
1269  
1270  	if (unlikely(!ctxi_src->rht_out)) {
1271  		dev_dbg(dev, "%s: Nothing to clone\n", __func__);
1272  		goto out_success;
1273  	}
1274  
1275  	/* User specified permission on attach */
1276  	perms = ctxi_dst->rht_perms;
1277  
1278  	/*
1279  	 * Copy over checked-out RHT (and their associated LXT) entries by
1280  	 * hand, stopping after we've copied all outstanding entries and
1281  	 * cleaning up if the clone fails.
1282  	 *
1283  	 * Note: This loop is equivalent to performing cxlflash_disk_open and
1284  	 * cxlflash_vlun_resize. As such, LUN accounting needs to be taken into
1285  	 * account by attaching after each successful RHT entry clone. In the
1286  	 * event that a clone failure is experienced, the LUN detach is handled
1287  	 * via the cleanup performed by _cxlflash_disk_release.
1288  	 */
1289  	for (i = 0; i < MAX_RHT_PER_CONTEXT; i++) {
1290  		if (ctxi_src->rht_out == ctxi_dst->rht_out)
1291  			break;
1292  		if (ctxi_src->rht_start[i].nmask == 0)
1293  			continue;
1294  
1295  		/* Consume a destination RHT entry */
1296  		ctxi_dst->rht_out++;
1297  		ctxi_dst->rht_start[i].nmask = ctxi_src->rht_start[i].nmask;
1298  		ctxi_dst->rht_start[i].fp =
1299  		    SISL_RHT_FP_CLONE(ctxi_src->rht_start[i].fp, perms);
1300  		ctxi_dst->rht_lun[i] = ctxi_src->rht_lun[i];
1301  
1302  		rc = clone_lxt(afu, blka, ctxid_dst, i,
1303  			       &ctxi_dst->rht_start[i],
1304  			       &ctxi_src->rht_start[i]);
1305  		if (rc) {
1306  			marshal_clone_to_rele(clone, &release);
1307  			for (j = 0; j < i; j++) {
1308  				release.rsrc_handle = j;
1309  				_cxlflash_disk_release(sdev, ctxi_dst,
1310  						       &release);
1311  			}
1312  
1313  			/* Put back the one we failed on */
1314  			rhte_checkin(ctxi_dst, &ctxi_dst->rht_start[i]);
1315  			goto err;
1316  		}
1317  
1318  		cxlflash_lun_attach(gli, gli->mode, false);
1319  	}
1320  
1321  out_success:
1322  	list_splice(&sidecar, &ctxi_dst->luns);
1323  
1324  	/* fall through */
1325  out:
1326  	if (ctxi_src)
1327  		put_context(ctxi_src);
1328  	if (ctxi_dst)
1329  		put_context(ctxi_dst);
1330  	dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
1331  	return rc;
1332  
1333  err:
1334  	list_for_each_entry_safe(lun_access_src, lun_access_dst, &sidecar, list)
1335  		kfree(lun_access_src);
1336  	goto out;
1337  }
1338