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