]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/scsi/cxlflash/superpipe.c
scsi: cxlflash: Support SQ Command Mode
[mirror_ubuntu-zesty-kernel.git] / drivers / scsi / cxlflash / superpipe.c
CommitLineData
65be2c79
MO
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/delay.h>
16#include <linux/file.h>
17#include <linux/syscalls.h>
18#include <misc/cxl.h>
19#include <asm/unaligned.h>
20
21#include <scsi/scsi.h>
22#include <scsi/scsi_host.h>
23#include <scsi/scsi_cmnd.h>
24#include <scsi/scsi_eh.h>
25#include <uapi/scsi/cxlflash_ioctl.h>
26
27#include "sislite.h"
28#include "common.h"
2cb79266 29#include "vlun.h"
65be2c79
MO
30#include "superpipe.h"
31
32struct cxlflash_global global;
33
2cb79266
MO
34/**
35 * marshal_rele_to_resize() - translate release to resize structure
36 * @rele: Source structure from which to translate/copy.
37 * @resize: Destination structure for the translate/copy.
38 */
39static void marshal_rele_to_resize(struct dk_cxlflash_release *release,
40 struct dk_cxlflash_resize *resize)
41{
42 resize->hdr = release->hdr;
43 resize->context_id = release->context_id;
44 resize->rsrc_handle = release->rsrc_handle;
45}
46
65be2c79
MO
47/**
48 * marshal_det_to_rele() - translate detach to release structure
49 * @detach: Destination structure for the translate/copy.
50 * @rele: Source structure from which to translate/copy.
51 */
52static void marshal_det_to_rele(struct dk_cxlflash_detach *detach,
53 struct dk_cxlflash_release *release)
54{
55 release->hdr = detach->hdr;
56 release->context_id = detach->context_id;
57}
58
59/**
60 * cxlflash_free_errpage() - frees resources associated with global error page
61 */
62void cxlflash_free_errpage(void)
63{
64
65 mutex_lock(&global.mutex);
66 if (global.err_page) {
67 __free_page(global.err_page);
68 global.err_page = NULL;
69 }
70 mutex_unlock(&global.mutex);
71}
72
73/**
74 * cxlflash_stop_term_user_contexts() - stops/terminates known user contexts
75 * @cfg: Internal structure associated with the host.
76 *
77 * When the host needs to go down, all users must be quiesced and their
78 * memory freed. This is accomplished by putting the contexts in error
f15fbf8d 79 * state which will notify the user and let them 'drive' the tear down.
65be2c79
MO
80 * Meanwhile, this routine camps until all user contexts have been removed.
81 */
82void cxlflash_stop_term_user_contexts(struct cxlflash_cfg *cfg)
83{
84 struct device *dev = &cfg->dev->dev;
85 int i, found;
86
87 cxlflash_mark_contexts_error(cfg);
88
89 while (true) {
90 found = false;
91
92 for (i = 0; i < MAX_CONTEXT; i++)
93 if (cfg->ctx_tbl[i]) {
94 found = true;
95 break;
96 }
97
98 if (!found && list_empty(&cfg->ctx_err_recovery))
99 return;
100
101 dev_dbg(dev, "%s: Wait for user contexts to quiesce...\n",
102 __func__);
439e85c1 103 wake_up_all(&cfg->reset_waitq);
65be2c79
MO
104 ssleep(1);
105 }
106}
107
108/**
109 * find_error_context() - locates a context by cookie on the error recovery list
110 * @cfg: Internal structure associated with the host.
111 * @rctxid: Desired context by id.
112 * @file: Desired context by file.
113 *
114 * Return: Found context on success, NULL on failure
115 */
116static struct ctx_info *find_error_context(struct cxlflash_cfg *cfg, u64 rctxid,
117 struct file *file)
118{
119 struct ctx_info *ctxi;
120
121 list_for_each_entry(ctxi, &cfg->ctx_err_recovery, list)
122 if ((ctxi->ctxid == rctxid) || (ctxi->file == file))
123 return ctxi;
124
125 return NULL;
126}
127
128/**
129 * get_context() - obtains a validated and locked context reference
130 * @cfg: Internal structure associated with the host.
131 * @rctxid: Desired context (raw, un-decoded format).
132 * @arg: LUN information or file associated with request.
133 * @ctx_ctrl: Control information to 'steer' desired lookup.
134 *
135 * NOTE: despite the name pid, in linux, current->pid actually refers
136 * to the lightweight process id (tid) and can change if the process is
137 * multi threaded. The tgid remains constant for the process and only changes
138 * when the process of fork. For all intents and purposes, think of tgid
139 * as a pid in the traditional sense.
140 *
141 * Return: Validated context on success, NULL on failure
142 */
143struct ctx_info *get_context(struct cxlflash_cfg *cfg, u64 rctxid,
144 void *arg, enum ctx_ctrl ctx_ctrl)
145{
146 struct device *dev = &cfg->dev->dev;
147 struct ctx_info *ctxi = NULL;
148 struct lun_access *lun_access = NULL;
149 struct file *file = NULL;
150 struct llun_info *lli = arg;
151 u64 ctxid = DECODE_CTXID(rctxid);
152 int rc;
153 pid_t pid = current->tgid, ctxpid = 0;
154
155 if (ctx_ctrl & CTX_CTRL_FILE) {
156 lli = NULL;
157 file = (struct file *)arg;
158 }
159
160 if (ctx_ctrl & CTX_CTRL_CLONE)
161 pid = current->parent->tgid;
162
163 if (likely(ctxid < MAX_CONTEXT)) {
164 while (true) {
a82544c7 165 mutex_lock(&cfg->ctx_tbl_list_mutex);
65be2c79
MO
166 ctxi = cfg->ctx_tbl[ctxid];
167 if (ctxi)
168 if ((file && (ctxi->file != file)) ||
169 (!file && (ctxi->ctxid != rctxid)))
170 ctxi = NULL;
171
172 if ((ctx_ctrl & CTX_CTRL_ERR) ||
173 (!ctxi && (ctx_ctrl & CTX_CTRL_ERR_FALLBACK)))
174 ctxi = find_error_context(cfg, rctxid, file);
175 if (!ctxi) {
176 mutex_unlock(&cfg->ctx_tbl_list_mutex);
177 goto out;
178 }
179
180 /*
181 * Need to acquire ownership of the context while still
182 * under the table/list lock to serialize with a remove
183 * thread. Use the 'try' to avoid stalling the
184 * table/list lock for a single context.
185 *
186 * Note that the lock order is:
187 *
188 * cfg->ctx_tbl_list_mutex -> ctxi->mutex
189 *
190 * Therefore release ctx_tbl_list_mutex before retrying.
191 */
192 rc = mutex_trylock(&ctxi->mutex);
193 mutex_unlock(&cfg->ctx_tbl_list_mutex);
194 if (rc)
195 break; /* got the context's lock! */
196 }
197
198 if (ctxi->unavail)
199 goto denied;
200
201 ctxpid = ctxi->pid;
202 if (likely(!(ctx_ctrl & CTX_CTRL_NOPID)))
203 if (pid != ctxpid)
204 goto denied;
205
206 if (lli) {
207 list_for_each_entry(lun_access, &ctxi->luns, list)
208 if (lun_access->lli == lli)
209 goto out;
210 goto denied;
211 }
212 }
213
214out:
215 dev_dbg(dev, "%s: rctxid=%016llX ctxinfo=%p ctxpid=%u pid=%u "
216 "ctx_ctrl=%u\n", __func__, rctxid, ctxi, ctxpid, pid,
217 ctx_ctrl);
218
219 return ctxi;
220
221denied:
222 mutex_unlock(&ctxi->mutex);
223 ctxi = NULL;
224 goto out;
225}
226
227/**
228 * put_context() - release a context that was retrieved from get_context()
229 * @ctxi: Context to release.
230 *
231 * For now, releasing the context equates to unlocking it's mutex.
232 */
233void put_context(struct ctx_info *ctxi)
234{
235 mutex_unlock(&ctxi->mutex);
236}
237
238/**
239 * afu_attach() - attach a context to the AFU
240 * @cfg: Internal structure associated with the host.
241 * @ctxi: Context to attach.
242 *
243 * Upon setting the context capabilities, they must be confirmed with
244 * a read back operation as the context might have been closed since
245 * the mailbox was unlocked. When this occurs, registration is failed.
246 *
247 * Return: 0 on success, -errno on failure
248 */
249static int afu_attach(struct cxlflash_cfg *cfg, struct ctx_info *ctxi)
250{
251 struct device *dev = &cfg->dev->dev;
252 struct afu *afu = cfg->afu;
1786f4a0 253 struct sisl_ctrl_map __iomem *ctrl_map = ctxi->ctrl_map;
65be2c79
MO
254 int rc = 0;
255 u64 val;
256
257 /* Unlock cap and restrict user to read/write cmds in translated mode */
258 readq_be(&ctrl_map->mbox_r);
259 val = (SISL_CTX_CAP_READ_CMD | SISL_CTX_CAP_WRITE_CMD);
260 writeq_be(val, &ctrl_map->ctx_cap);
261 val = readq_be(&ctrl_map->ctx_cap);
262 if (val != (SISL_CTX_CAP_READ_CMD | SISL_CTX_CAP_WRITE_CMD)) {
263 dev_err(dev, "%s: ctx may be closed val=%016llX\n",
264 __func__, val);
265 rc = -EAGAIN;
266 goto out;
267 }
268
269 /* Set up MMIO registers pointing to the RHT */
270 writeq_be((u64)ctxi->rht_start, &ctrl_map->rht_start);
271 val = SISL_RHT_CNT_ID((u64)MAX_RHT_PER_CONTEXT, (u64)(afu->ctx_hndl));
272 writeq_be(val, &ctrl_map->rht_cnt_id);
273out:
274 dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
275 return rc;
276}
277
278/**
279 * read_cap16() - issues a SCSI READ_CAP16 command
280 * @sdev: SCSI device associated with LUN.
281 * @lli: LUN destined for capacity request.
282 *
aacb4ff6
MO
283 * The READ_CAP16 can take quite a while to complete. Should an EEH occur while
284 * in scsi_execute(), the EEH handler will attempt to recover. As part of the
285 * recovery, the handler drains all currently running ioctls, waiting until they
286 * have completed before proceeding with a reset. As this routine is used on the
287 * ioctl path, this can create a condition where the EEH handler becomes stuck,
288 * infinitely waiting for this ioctl thread. To avoid this behavior, temporarily
289 * unmark this thread as an ioctl thread by releasing the ioctl read semaphore.
290 * This will allow the EEH handler to proceed with a recovery while this thread
291 * is still running. Once the scsi_execute() returns, reacquire the ioctl read
292 * semaphore and check the adapter state in case it changed while inside of
293 * scsi_execute(). The state check will wait if the adapter is still being
294 * recovered or return a failure if the recovery failed. In the event that the
295 * adapter reset failed, simply return the failure as the ioctl would be unable
296 * to continue.
297 *
298 * Note that the above puts a requirement on this routine to only be called on
299 * an ioctl thread.
300 *
65be2c79
MO
301 * Return: 0 on success, -errno on failure
302 */
303static int read_cap16(struct scsi_device *sdev, struct llun_info *lli)
304{
305 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
306 struct device *dev = &cfg->dev->dev;
307 struct glun_info *gli = lli->parent;
308 u8 *cmd_buf = NULL;
309 u8 *scsi_cmd = NULL;
310 u8 *sense_buf = NULL;
311 int rc = 0;
312 int result = 0;
313 int retry_cnt = 0;
471a5a60 314 u32 to = CMD_TIMEOUT * HZ;
65be2c79
MO
315
316retry:
317 cmd_buf = kzalloc(CMD_BUFSIZE, GFP_KERNEL);
318 scsi_cmd = kzalloc(MAX_COMMAND_SIZE, GFP_KERNEL);
319 sense_buf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_KERNEL);
320 if (unlikely(!cmd_buf || !scsi_cmd || !sense_buf)) {
321 rc = -ENOMEM;
322 goto out;
323 }
324
325 scsi_cmd[0] = SERVICE_ACTION_IN_16; /* read cap(16) */
326 scsi_cmd[1] = SAI_READ_CAPACITY_16; /* service action */
327 put_unaligned_be32(CMD_BUFSIZE, &scsi_cmd[10]);
328
329 dev_dbg(dev, "%s: %ssending cmd(0x%x)\n", __func__,
330 retry_cnt ? "re" : "", scsi_cmd[0]);
331
aacb4ff6
MO
332 /* Drop the ioctl read semahpore across lengthy call */
333 up_read(&cfg->ioctl_rwsem);
65be2c79 334 result = scsi_execute(sdev, scsi_cmd, DMA_FROM_DEVICE, cmd_buf,
471a5a60 335 CMD_BUFSIZE, sense_buf, to, CMD_RETRIES, 0, NULL);
aacb4ff6
MO
336 down_read(&cfg->ioctl_rwsem);
337 rc = check_state(cfg);
338 if (rc) {
339 dev_err(dev, "%s: Failed state! result=0x08%X\n",
340 __func__, result);
341 rc = -ENODEV;
342 goto out;
343 }
65be2c79
MO
344
345 if (driver_byte(result) == DRIVER_SENSE) {
346 result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
347 if (result & SAM_STAT_CHECK_CONDITION) {
348 struct scsi_sense_hdr sshdr;
349
350 scsi_normalize_sense(sense_buf, SCSI_SENSE_BUFFERSIZE,
351 &sshdr);
352 switch (sshdr.sense_key) {
353 case NO_SENSE:
354 case RECOVERED_ERROR:
355 /* fall through */
356 case NOT_READY:
357 result &= ~SAM_STAT_CHECK_CONDITION;
358 break;
359 case UNIT_ATTENTION:
360 switch (sshdr.asc) {
361 case 0x29: /* Power on Reset or Device Reset */
362 /* fall through */
363 case 0x2A: /* Device capacity changed */
364 case 0x3F: /* Report LUNs changed */
365 /* Retry the command once more */
366 if (retry_cnt++ < 1) {
367 kfree(cmd_buf);
368 kfree(scsi_cmd);
369 kfree(sense_buf);
370 goto retry;
371 }
372 }
373 break;
374 default:
375 break;
376 }
377 }
378 }
379
380 if (result) {
381 dev_err(dev, "%s: command failed, result=0x%x\n",
382 __func__, result);
383 rc = -EIO;
384 goto out;
385 }
386
387 /*
388 * Read cap was successful, grab values from the buffer;
389 * note that we don't need to worry about unaligned access
390 * as the buffer is allocated on an aligned boundary.
391 */
392 mutex_lock(&gli->mutex);
1786f4a0
MO
393 gli->max_lba = be64_to_cpu(*((__be64 *)&cmd_buf[0]));
394 gli->blk_len = be32_to_cpu(*((__be32 *)&cmd_buf[8]));
65be2c79
MO
395 mutex_unlock(&gli->mutex);
396
397out:
398 kfree(cmd_buf);
399 kfree(scsi_cmd);
400 kfree(sense_buf);
401
402 dev_dbg(dev, "%s: maxlba=%lld blklen=%d rc=%d\n",
403 __func__, gli->max_lba, gli->blk_len, rc);
404 return rc;
405}
406
407/**
408 * get_rhte() - obtains validated resource handle table entry reference
409 * @ctxi: Context owning the resource handle.
410 * @rhndl: Resource handle associated with entry.
411 * @lli: LUN associated with request.
412 *
413 * Return: Validated RHTE on success, NULL on failure
414 */
415struct sisl_rht_entry *get_rhte(struct ctx_info *ctxi, res_hndl_t rhndl,
416 struct llun_info *lli)
417{
418 struct sisl_rht_entry *rhte = NULL;
419
420 if (unlikely(!ctxi->rht_start)) {
421 pr_debug("%s: Context does not have allocated RHT!\n",
422 __func__);
423 goto out;
424 }
425
426 if (unlikely(rhndl >= MAX_RHT_PER_CONTEXT)) {
427 pr_debug("%s: Bad resource handle! (%d)\n", __func__, rhndl);
428 goto out;
429 }
430
431 if (unlikely(ctxi->rht_lun[rhndl] != lli)) {
432 pr_debug("%s: Bad resource handle LUN! (%d)\n",
433 __func__, rhndl);
434 goto out;
435 }
436
437 rhte = &ctxi->rht_start[rhndl];
438 if (unlikely(rhte->nmask == 0)) {
439 pr_debug("%s: Unopened resource handle! (%d)\n",
440 __func__, rhndl);
441 rhte = NULL;
442 goto out;
443 }
444
445out:
446 return rhte;
447}
448
449/**
450 * rhte_checkout() - obtains free/empty resource handle table entry
451 * @ctxi: Context owning the resource handle.
452 * @lli: LUN associated with request.
453 *
454 * Return: Free RHTE on success, NULL on failure
455 */
456struct sisl_rht_entry *rhte_checkout(struct ctx_info *ctxi,
457 struct llun_info *lli)
458{
459 struct sisl_rht_entry *rhte = NULL;
460 int i;
461
462 /* Find a free RHT entry */
463 for (i = 0; i < MAX_RHT_PER_CONTEXT; i++)
464 if (ctxi->rht_start[i].nmask == 0) {
465 rhte = &ctxi->rht_start[i];
466 ctxi->rht_out++;
467 break;
468 }
469
470 if (likely(rhte))
471 ctxi->rht_lun[i] = lli;
472
473 pr_debug("%s: returning rhte=%p (%d)\n", __func__, rhte, i);
474 return rhte;
475}
476
477/**
478 * rhte_checkin() - releases a resource handle table entry
479 * @ctxi: Context owning the resource handle.
480 * @rhte: RHTE to release.
481 */
482void rhte_checkin(struct ctx_info *ctxi,
483 struct sisl_rht_entry *rhte)
484{
485 u32 rsrc_handle = rhte - ctxi->rht_start;
486
487 rhte->nmask = 0;
488 rhte->fp = 0;
489 ctxi->rht_out--;
490 ctxi->rht_lun[rsrc_handle] = NULL;
2cb79266 491 ctxi->rht_needs_ws[rsrc_handle] = false;
65be2c79
MO
492}
493
494/**
495 * rhte_format1() - populates a RHTE for format 1
496 * @rhte: RHTE to populate.
497 * @lun_id: LUN ID of LUN associated with RHTE.
498 * @perm: Desired permissions for RHTE.
499 * @port_sel: Port selection mask
500 */
501static void rht_format1(struct sisl_rht_entry *rhte, u64 lun_id, u32 perm,
502 u32 port_sel)
503{
504 /*
505 * Populate the Format 1 RHT entry for direct access (physical
506 * LUN) using the synchronization sequence defined in the
507 * SISLite specification.
508 */
509 struct sisl_rht_entry_f1 dummy = { 0 };
510 struct sisl_rht_entry_f1 *rhte_f1 = (struct sisl_rht_entry_f1 *)rhte;
511
512 memset(rhte_f1, 0, sizeof(*rhte_f1));
513 rhte_f1->fp = SISL_RHT_FP(1U, 0);
514 dma_wmb(); /* Make setting of format bit visible */
515
516 rhte_f1->lun_id = lun_id;
517 dma_wmb(); /* Make setting of LUN id visible */
518
519 /*
520 * Use a dummy RHT Format 1 entry to build the second dword
521 * of the entry that must be populated in a single write when
522 * enabled (valid bit set to TRUE).
523 */
524 dummy.valid = 0x80;
525 dummy.fp = SISL_RHT_FP(1U, perm);
526 dummy.port_sel = port_sel;
527 rhte_f1->dw = dummy.dw;
528
529 dma_wmb(); /* Make remaining RHT entry fields visible */
530}
531
532/**
533 * cxlflash_lun_attach() - attaches a user to a LUN and manages the LUN's mode
534 * @gli: LUN to attach.
535 * @mode: Desired mode of the LUN.
536 * @locked: Mutex status on current thread.
537 *
538 * Return: 0 on success, -errno on failure
539 */
540int cxlflash_lun_attach(struct glun_info *gli, enum lun_mode mode, bool locked)
541{
542 int rc = 0;
543
544 if (!locked)
545 mutex_lock(&gli->mutex);
546
547 if (gli->mode == MODE_NONE)
548 gli->mode = mode;
549 else if (gli->mode != mode) {
550 pr_debug("%s: LUN operating in mode %d, requested mode %d\n",
551 __func__, gli->mode, mode);
552 rc = -EINVAL;
553 goto out;
554 }
555
556 gli->users++;
557 WARN_ON(gli->users <= 0);
558out:
559 pr_debug("%s: Returning rc=%d gli->mode=%u gli->users=%u\n",
560 __func__, rc, gli->mode, gli->users);
561 if (!locked)
562 mutex_unlock(&gli->mutex);
563 return rc;
564}
565
566/**
567 * cxlflash_lun_detach() - detaches a user from a LUN and resets the LUN's mode
568 * @gli: LUN to detach.
2cb79266
MO
569 *
570 * When resetting the mode, terminate block allocation resources as they
571 * are no longer required (service is safe to call even when block allocation
572 * resources were not present - such as when transitioning from physical mode).
573 * These resources will be reallocated when needed (subsequent transition to
574 * virtual mode).
65be2c79
MO
575 */
576void cxlflash_lun_detach(struct glun_info *gli)
577{
578 mutex_lock(&gli->mutex);
579 WARN_ON(gli->mode == MODE_NONE);
2cb79266 580 if (--gli->users == 0) {
65be2c79 581 gli->mode = MODE_NONE;
2cb79266
MO
582 cxlflash_ba_terminate(&gli->blka.ba_lun);
583 }
65be2c79
MO
584 pr_debug("%s: gli->users=%u\n", __func__, gli->users);
585 WARN_ON(gli->users < 0);
586 mutex_unlock(&gli->mutex);
587}
588
589/**
590 * _cxlflash_disk_release() - releases the specified resource entry
591 * @sdev: SCSI device associated with LUN.
592 * @ctxi: Context owning resources.
593 * @release: Release ioctl data structure.
594 *
2cb79266
MO
595 * For LUNs in virtual mode, the virtual LUN associated with the specified
596 * resource handle is resized to 0 prior to releasing the RHTE. Note that the
597 * AFU sync should _not_ be performed when the context is sitting on the error
598 * recovery list. A context on the error recovery list is not known to the AFU
599 * due to reset. When the context is recovered, it will be reattached and made
600 * known again to the AFU.
65be2c79
MO
601 *
602 * Return: 0 on success, -errno on failure
603 */
604int _cxlflash_disk_release(struct scsi_device *sdev,
605 struct ctx_info *ctxi,
606 struct dk_cxlflash_release *release)
607{
608 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
609 struct device *dev = &cfg->dev->dev;
610 struct llun_info *lli = sdev->hostdata;
611 struct glun_info *gli = lli->parent;
612 struct afu *afu = cfg->afu;
613 bool put_ctx = false;
614
2cb79266 615 struct dk_cxlflash_resize size;
65be2c79
MO
616 res_hndl_t rhndl = release->rsrc_handle;
617
618 int rc = 0;
619 u64 ctxid = DECODE_CTXID(release->context_id),
620 rctxid = release->context_id;
621
622 struct sisl_rht_entry *rhte;
623 struct sisl_rht_entry_f1 *rhte_f1;
624
625 dev_dbg(dev, "%s: ctxid=%llu rhndl=0x%llx gli->mode=%u gli->users=%u\n",
626 __func__, ctxid, release->rsrc_handle, gli->mode, gli->users);
627
628 if (!ctxi) {
629 ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
630 if (unlikely(!ctxi)) {
631 dev_dbg(dev, "%s: Bad context! (%llu)\n",
632 __func__, ctxid);
633 rc = -EINVAL;
634 goto out;
635 }
636
637 put_ctx = true;
638 }
639
640 rhte = get_rhte(ctxi, rhndl, lli);
641 if (unlikely(!rhte)) {
642 dev_dbg(dev, "%s: Bad resource handle! (%d)\n",
643 __func__, rhndl);
644 rc = -EINVAL;
645 goto out;
646 }
647
2cb79266
MO
648 /*
649 * Resize to 0 for virtual LUNS by setting the size
650 * to 0. This will clear LXT_START and LXT_CNT fields
651 * in the RHT entry and properly sync with the AFU.
652 *
653 * Afterwards we clear the remaining fields.
654 */
65be2c79 655 switch (gli->mode) {
2cb79266
MO
656 case MODE_VIRTUAL:
657 marshal_rele_to_resize(release, &size);
658 size.req_size = 0;
659 rc = _cxlflash_vlun_resize(sdev, ctxi, &size);
660 if (rc) {
661 dev_dbg(dev, "%s: resize failed rc %d\n", __func__, rc);
662 goto out;
663 }
664
665 break;
65be2c79
MO
666 case MODE_PHYSICAL:
667 /*
668 * Clear the Format 1 RHT entry for direct access
669 * (physical LUN) using the synchronization sequence
670 * defined in the SISLite specification.
671 */
672 rhte_f1 = (struct sisl_rht_entry_f1 *)rhte;
673
674 rhte_f1->valid = 0;
675 dma_wmb(); /* Make revocation of RHT entry visible */
676
677 rhte_f1->lun_id = 0;
678 dma_wmb(); /* Make clearing of LUN id visible */
679
680 rhte_f1->dw = 0;
681 dma_wmb(); /* Make RHT entry bottom-half clearing visible */
682
683 if (!ctxi->err_recovery_active)
684 cxlflash_afu_sync(afu, ctxid, rhndl, AFU_HW_SYNC);
685 break;
686 default:
687 WARN(1, "Unsupported LUN mode!");
688 goto out;
689 }
690
691 rhte_checkin(ctxi, rhte);
692 cxlflash_lun_detach(gli);
693
694out:
695 if (put_ctx)
696 put_context(ctxi);
697 dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
698 return rc;
699}
700
701int cxlflash_disk_release(struct scsi_device *sdev,
702 struct dk_cxlflash_release *release)
703{
704 return _cxlflash_disk_release(sdev, NULL, release);
705}
706
707/**
708 * destroy_context() - releases a context
709 * @cfg: Internal structure associated with the host.
710 * @ctxi: Context to release.
711 *
41b99e1a
MO
712 * This routine is safe to be called with a a non-initialized context.
713 * Also note that the routine conditionally checks for the existence
714 * of the context control map before clearing the RHT registers and
715 * context capabilities because it is possible to destroy a context
716 * while the context is in the error state (previous mapping was
717 * removed [so there is no need to worry about clearing] and context
718 * is waiting for a new mapping).
65be2c79
MO
719 */
720static void destroy_context(struct cxlflash_cfg *cfg,
721 struct ctx_info *ctxi)
722{
723 struct afu *afu = cfg->afu;
724
5e6632d1
MO
725 if (ctxi->initialized) {
726 WARN_ON(!list_empty(&ctxi->luns));
65be2c79 727
5e6632d1
MO
728 /* Clear RHT registers and drop all capabilities for context */
729 if (afu->afu_map && ctxi->ctrl_map) {
730 writeq_be(0, &ctxi->ctrl_map->rht_start);
731 writeq_be(0, &ctxi->ctrl_map->rht_cnt_id);
732 writeq_be(0, &ctxi->ctrl_map->ctx_cap);
733 }
65be2c79
MO
734 }
735
736 /* Free memory associated with context */
737 free_page((ulong)ctxi->rht_start);
2cb79266 738 kfree(ctxi->rht_needs_ws);
65be2c79
MO
739 kfree(ctxi->rht_lun);
740 kfree(ctxi);
65be2c79
MO
741}
742
743/**
744 * create_context() - allocates and initializes a context
745 * @cfg: Internal structure associated with the host.
65be2c79
MO
746 *
747 * Return: Allocated context on success, NULL on failure
748 */
5e6632d1 749static struct ctx_info *create_context(struct cxlflash_cfg *cfg)
65be2c79
MO
750{
751 struct device *dev = &cfg->dev->dev;
65be2c79
MO
752 struct ctx_info *ctxi = NULL;
753 struct llun_info **lli = NULL;
e568e23f 754 u8 *ws = NULL;
65be2c79
MO
755 struct sisl_rht_entry *rhte;
756
757 ctxi = kzalloc(sizeof(*ctxi), GFP_KERNEL);
758 lli = kzalloc((MAX_RHT_PER_CONTEXT * sizeof(*lli)), GFP_KERNEL);
2cb79266
MO
759 ws = kzalloc((MAX_RHT_PER_CONTEXT * sizeof(*ws)), GFP_KERNEL);
760 if (unlikely(!ctxi || !lli || !ws)) {
65be2c79
MO
761 dev_err(dev, "%s: Unable to allocate context!\n", __func__);
762 goto err;
763 }
764
765 rhte = (struct sisl_rht_entry *)get_zeroed_page(GFP_KERNEL);
766 if (unlikely(!rhte)) {
767 dev_err(dev, "%s: Unable to allocate RHT!\n", __func__);
768 goto err;
769 }
770
771 ctxi->rht_lun = lli;
2cb79266 772 ctxi->rht_needs_ws = ws;
65be2c79 773 ctxi->rht_start = rhte;
5e6632d1
MO
774out:
775 return ctxi;
776
777err:
778 kfree(ws);
779 kfree(lli);
780 kfree(ctxi);
781 ctxi = NULL;
782 goto out;
783}
784
785/**
786 * init_context() - initializes a previously allocated context
787 * @ctxi: Previously allocated context
788 * @cfg: Internal structure associated with the host.
789 * @ctx: Previously obtained CXL context reference.
790 * @ctxid: Previously obtained process element associated with CXL context.
5e6632d1
MO
791 * @file: Previously obtained file associated with CXL context.
792 * @perms: User-specified permissions.
5e6632d1
MO
793 */
794static void init_context(struct ctx_info *ctxi, struct cxlflash_cfg *cfg,
de9f0b0c
MO
795 struct cxl_context *ctx, int ctxid, struct file *file,
796 u32 perms)
5e6632d1
MO
797{
798 struct afu *afu = cfg->afu;
65be2c79 799
5e6632d1 800 ctxi->rht_perms = perms;
65be2c79
MO
801 ctxi->ctrl_map = &afu->afu_map->ctrls[ctxid].ctrl;
802 ctxi->ctxid = ENCODE_CTXID(ctxi, ctxid);
65be2c79
MO
803 ctxi->pid = current->tgid; /* tgid = pid */
804 ctxi->ctx = ctx;
44ef38f9 805 ctxi->cfg = cfg;
65be2c79 806 ctxi->file = file;
5e6632d1 807 ctxi->initialized = true;
65be2c79 808 mutex_init(&ctxi->mutex);
888baf06 809 kref_init(&ctxi->kref);
65be2c79
MO
810 INIT_LIST_HEAD(&ctxi->luns);
811 INIT_LIST_HEAD(&ctxi->list); /* initialize for list_empty() */
65be2c79
MO
812}
813
888baf06
MO
814/**
815 * remove_context() - context kref release handler
816 * @kref: Kernel reference associated with context to be removed.
817 *
818 * When a context no longer has any references it can safely be removed
819 * from global access and destroyed. Note that it is assumed the thread
820 * relinquishing access to the context holds its mutex.
821 */
822static void remove_context(struct kref *kref)
823{
824 struct ctx_info *ctxi = container_of(kref, struct ctx_info, kref);
825 struct cxlflash_cfg *cfg = ctxi->cfg;
888baf06
MO
826 u64 ctxid = DECODE_CTXID(ctxi->ctxid);
827
828 /* Remove context from table/error list */
829 WARN_ON(!mutex_is_locked(&ctxi->mutex));
830 ctxi->unavail = true;
831 mutex_unlock(&ctxi->mutex);
832 mutex_lock(&cfg->ctx_tbl_list_mutex);
833 mutex_lock(&ctxi->mutex);
834
835 if (!list_empty(&ctxi->list))
836 list_del(&ctxi->list);
837 cfg->ctx_tbl[ctxid] = NULL;
838 mutex_unlock(&cfg->ctx_tbl_list_mutex);
839 mutex_unlock(&ctxi->mutex);
840
841 /* Context now completely uncoupled/unreachable */
888baf06 842 destroy_context(cfg, ctxi);
888baf06
MO
843}
844
65be2c79
MO
845/**
846 * _cxlflash_disk_detach() - detaches a LUN from a context
847 * @sdev: SCSI device associated with LUN.
848 * @ctxi: Context owning resources.
849 * @detach: Detach ioctl data structure.
850 *
851 * As part of the detach, all per-context resources associated with the LUN
852 * are cleaned up. When detaching the last LUN for a context, the context
853 * itself is cleaned up and released.
854 *
855 * Return: 0 on success, -errno on failure
856 */
857static int _cxlflash_disk_detach(struct scsi_device *sdev,
858 struct ctx_info *ctxi,
859 struct dk_cxlflash_detach *detach)
860{
861 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
862 struct device *dev = &cfg->dev->dev;
863 struct llun_info *lli = sdev->hostdata;
864 struct lun_access *lun_access, *t;
865 struct dk_cxlflash_release rel;
866 bool put_ctx = false;
867
868 int i;
869 int rc = 0;
65be2c79
MO
870 u64 ctxid = DECODE_CTXID(detach->context_id),
871 rctxid = detach->context_id;
872
873 dev_dbg(dev, "%s: ctxid=%llu\n", __func__, ctxid);
874
875 if (!ctxi) {
876 ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
877 if (unlikely(!ctxi)) {
878 dev_dbg(dev, "%s: Bad context! (%llu)\n",
879 __func__, ctxid);
880 rc = -EINVAL;
881 goto out;
882 }
883
884 put_ctx = true;
885 }
886
887 /* Cleanup outstanding resources tied to this LUN */
888 if (ctxi->rht_out) {
889 marshal_det_to_rele(detach, &rel);
890 for (i = 0; i < MAX_RHT_PER_CONTEXT; i++) {
891 if (ctxi->rht_lun[i] == lli) {
892 rel.rsrc_handle = i;
893 _cxlflash_disk_release(sdev, ctxi, &rel);
894 }
895
896 /* No need to loop further if we're done */
897 if (ctxi->rht_out == 0)
898 break;
899 }
900 }
901
902 /* Take our LUN out of context, free the node */
903 list_for_each_entry_safe(lun_access, t, &ctxi->luns, list)
904 if (lun_access->lli == lli) {
905 list_del(&lun_access->list);
906 kfree(lun_access);
907 lun_access = NULL;
908 break;
909 }
910
888baf06
MO
911 /*
912 * Release the context reference and the sdev reference that
913 * bound this LUN to the context.
914 */
c4a11827
MO
915 if (kref_put(&ctxi->kref, remove_context))
916 put_ctx = false;
22fe1ae8 917 scsi_device_put(sdev);
65be2c79
MO
918out:
919 if (put_ctx)
920 put_context(ctxi);
921 dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
922 return rc;
923}
924
925static int cxlflash_disk_detach(struct scsi_device *sdev,
926 struct dk_cxlflash_detach *detach)
927{
928 return _cxlflash_disk_detach(sdev, NULL, detach);
929}
930
931/**
932 * cxlflash_cxl_release() - release handler for adapter file descriptor
933 * @inode: File-system inode associated with fd.
934 * @file: File installed with adapter file descriptor.
935 *
936 * This routine is the release handler for the fops registered with
937 * the CXL services on an initial attach for a context. It is called
cd34af40
MO
938 * when a close (explicity by the user or as part of a process tear
939 * down) is performed on the adapter file descriptor returned to the
940 * user. The user should be aware that explicitly performing a close
941 * considered catastrophic and subsequent usage of the superpipe API
942 * with previously saved off tokens will fail.
65be2c79 943 *
cd34af40
MO
944 * This routine derives the context reference and calls detach for
945 * each LUN associated with the context.The final detach operation
946 * causes the context itself to be freed. With exception to when the
947 * CXL process element (context id) lookup fails (a case that should
948 * theoretically never occur), every call into this routine results
949 * in a complete freeing of a context.
65be2c79
MO
950 *
951 * Return: 0 on success
952 */
953static int cxlflash_cxl_release(struct inode *inode, struct file *file)
954{
955 struct cxl_context *ctx = cxl_fops_get_context(file);
956 struct cxlflash_cfg *cfg = container_of(file->f_op, struct cxlflash_cfg,
957 cxl_fops);
958 struct device *dev = &cfg->dev->dev;
959 struct ctx_info *ctxi = NULL;
960 struct dk_cxlflash_detach detach = { { 0 }, 0 };
961 struct lun_access *lun_access, *t;
962 enum ctx_ctrl ctrl = CTX_CTRL_ERR_FALLBACK | CTX_CTRL_FILE;
963 int ctxid;
964
965 ctxid = cxl_process_element(ctx);
966 if (unlikely(ctxid < 0)) {
967 dev_err(dev, "%s: Context %p was closed! (%d)\n",
968 __func__, ctx, ctxid);
969 goto out;
970 }
971
972 ctxi = get_context(cfg, ctxid, file, ctrl);
973 if (unlikely(!ctxi)) {
974 ctxi = get_context(cfg, ctxid, file, ctrl | CTX_CTRL_CLONE);
975 if (!ctxi) {
976 dev_dbg(dev, "%s: Context %d already free!\n",
977 __func__, ctxid);
978 goto out_release;
979 }
980
981 dev_dbg(dev, "%s: Another process owns context %d!\n",
982 __func__, ctxid);
983 put_context(ctxi);
984 goto out;
985 }
986
cd34af40 987 dev_dbg(dev, "%s: close for context %d\n", __func__, ctxid);
65be2c79 988
65be2c79
MO
989 detach.context_id = ctxi->ctxid;
990 list_for_each_entry_safe(lun_access, t, &ctxi->luns, list)
991 _cxlflash_disk_detach(lun_access->sdev, ctxi, &detach);
992out_release:
993 cxl_fd_release(inode, file);
994out:
995 dev_dbg(dev, "%s: returning\n", __func__);
996 return 0;
997}
998
999/**
1000 * unmap_context() - clears a previously established mapping
1001 * @ctxi: Context owning the mapping.
1002 *
1003 * This routine is used to switch between the error notification page
1004 * (dummy page of all 1's) and the real mapping (established by the CXL
1005 * fault handler).
1006 */
1007static void unmap_context(struct ctx_info *ctxi)
1008{
1009 unmap_mapping_range(ctxi->file->f_mapping, 0, 0, 1);
1010}
1011
1012/**
1013 * get_err_page() - obtains and allocates the error notification page
1014 *
1015 * Return: error notification page on success, NULL on failure
1016 */
1017static struct page *get_err_page(void)
1018{
1019 struct page *err_page = global.err_page;
1020
1021 if (unlikely(!err_page)) {
1022 err_page = alloc_page(GFP_KERNEL);
1023 if (unlikely(!err_page)) {
1024 pr_err("%s: Unable to allocate err_page!\n", __func__);
1025 goto out;
1026 }
1027
1028 memset(page_address(err_page), -1, PAGE_SIZE);
1029
1030 /* Serialize update w/ other threads to avoid a leak */
1031 mutex_lock(&global.mutex);
1032 if (likely(!global.err_page))
1033 global.err_page = err_page;
1034 else {
1035 __free_page(err_page);
1036 err_page = global.err_page;
1037 }
1038 mutex_unlock(&global.mutex);
1039 }
1040
1041out:
1042 pr_debug("%s: returning err_page=%p\n", __func__, err_page);
1043 return err_page;
1044}
1045
1046/**
1047 * cxlflash_mmap_fault() - mmap fault handler for adapter file descriptor
1048 * @vma: VM area associated with mapping.
1049 * @vmf: VM fault associated with current fault.
1050 *
1051 * To support error notification via MMIO, faults are 'caught' by this routine
1052 * that was inserted before passing back the adapter file descriptor on attach.
1053 * When a fault occurs, this routine evaluates if error recovery is active and
1054 * if so, installs the error page to 'notify' the user about the error state.
1055 * During normal operation, the fault is simply handled by the original fault
1056 * handler that was installed by CXL services as part of initializing the
1057 * adapter file descriptor. The VMA's page protection bits are toggled to
1058 * indicate cached/not-cached depending on the memory backing the fault.
1059 *
1060 * Return: 0 on success, VM_FAULT_SIGBUS on failure
1061 */
1062static int cxlflash_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1063{
1064 struct file *file = vma->vm_file;
1065 struct cxl_context *ctx = cxl_fops_get_context(file);
1066 struct cxlflash_cfg *cfg = container_of(file->f_op, struct cxlflash_cfg,
1067 cxl_fops);
1068 struct device *dev = &cfg->dev->dev;
1069 struct ctx_info *ctxi = NULL;
1070 struct page *err_page = NULL;
1071 enum ctx_ctrl ctrl = CTX_CTRL_ERR_FALLBACK | CTX_CTRL_FILE;
1072 int rc = 0;
1073 int ctxid;
1074
1075 ctxid = cxl_process_element(ctx);
1076 if (unlikely(ctxid < 0)) {
1077 dev_err(dev, "%s: Context %p was closed! (%d)\n",
1078 __func__, ctx, ctxid);
1079 goto err;
1080 }
1081
1082 ctxi = get_context(cfg, ctxid, file, ctrl);
1083 if (unlikely(!ctxi)) {
1084 dev_dbg(dev, "%s: Bad context! (%d)\n", __func__, ctxid);
1085 goto err;
1086 }
1087
de9f0b0c 1088 dev_dbg(dev, "%s: fault for context %d\n", __func__, ctxid);
65be2c79
MO
1089
1090 if (likely(!ctxi->err_recovery_active)) {
1091 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1092 rc = ctxi->cxl_mmap_vmops->fault(vma, vmf);
1093 } else {
1094 dev_dbg(dev, "%s: err recovery active, use err_page!\n",
1095 __func__);
1096
1097 err_page = get_err_page();
1098 if (unlikely(!err_page)) {
1099 dev_err(dev, "%s: Could not obtain error page!\n",
1100 __func__);
1101 rc = VM_FAULT_RETRY;
1102 goto out;
1103 }
1104
1105 get_page(err_page);
1106 vmf->page = err_page;
1107 vma->vm_page_prot = pgprot_cached(vma->vm_page_prot);
1108 }
1109
1110out:
1111 if (likely(ctxi))
1112 put_context(ctxi);
1113 dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc);
1114 return rc;
1115
1116err:
1117 rc = VM_FAULT_SIGBUS;
1118 goto out;
1119}
1120
1121/*
1122 * Local MMAP vmops to 'catch' faults
1123 */
1124static const struct vm_operations_struct cxlflash_mmap_vmops = {
1125 .fault = cxlflash_mmap_fault,
1126};
1127
1128/**
1129 * cxlflash_cxl_mmap() - mmap handler for adapter file descriptor
1130 * @file: File installed with adapter file descriptor.
1131 * @vma: VM area associated with mapping.
1132 *
1133 * Installs local mmap vmops to 'catch' faults for error notification support.
1134 *
1135 * Return: 0 on success, -errno on failure
1136 */
1137static int cxlflash_cxl_mmap(struct file *file, struct vm_area_struct *vma)
1138{
1139 struct cxl_context *ctx = cxl_fops_get_context(file);
1140 struct cxlflash_cfg *cfg = container_of(file->f_op, struct cxlflash_cfg,
1141 cxl_fops);
1142 struct device *dev = &cfg->dev->dev;
1143 struct ctx_info *ctxi = NULL;
1144 enum ctx_ctrl ctrl = CTX_CTRL_ERR_FALLBACK | CTX_CTRL_FILE;
1145 int ctxid;
1146 int rc = 0;
1147
1148 ctxid = cxl_process_element(ctx);
1149 if (unlikely(ctxid < 0)) {
1150 dev_err(dev, "%s: Context %p was closed! (%d)\n",
1151 __func__, ctx, ctxid);
1152 rc = -EIO;
1153 goto out;
1154 }
1155
1156 ctxi = get_context(cfg, ctxid, file, ctrl);
1157 if (unlikely(!ctxi)) {
1158 dev_dbg(dev, "%s: Bad context! (%d)\n", __func__, ctxid);
1159 rc = -EIO;
1160 goto out;
1161 }
1162
de9f0b0c 1163 dev_dbg(dev, "%s: mmap for context %d\n", __func__, ctxid);
65be2c79
MO
1164
1165 rc = cxl_fd_mmap(file, vma);
1166 if (likely(!rc)) {
1167 /* Insert ourself in the mmap fault handler path */
1168 ctxi->cxl_mmap_vmops = vma->vm_ops;
1169 vma->vm_ops = &cxlflash_mmap_vmops;
1170 }
1171
1172out:
1173 if (likely(ctxi))
1174 put_context(ctxi);
1175 return rc;
1176}
1177
17ead26f 1178const struct file_operations cxlflash_cxl_fops = {
65be2c79
MO
1179 .owner = THIS_MODULE,
1180 .mmap = cxlflash_cxl_mmap,
1181 .release = cxlflash_cxl_release,
1182};
1183
1184/**
1185 * cxlflash_mark_contexts_error() - move contexts to error state and list
1186 * @cfg: Internal structure associated with the host.
1187 *
1188 * A context is only moved over to the error list when there are no outstanding
1189 * references to it. This ensures that a running operation has completed.
1190 *
1191 * Return: 0 on success, -errno on failure
1192 */
1193int cxlflash_mark_contexts_error(struct cxlflash_cfg *cfg)
1194{
1195 int i, rc = 0;
1196 struct ctx_info *ctxi = NULL;
1197
1198 mutex_lock(&cfg->ctx_tbl_list_mutex);
1199
1200 for (i = 0; i < MAX_CONTEXT; i++) {
1201 ctxi = cfg->ctx_tbl[i];
1202 if (ctxi) {
1203 mutex_lock(&ctxi->mutex);
1204 cfg->ctx_tbl[i] = NULL;
1205 list_add(&ctxi->list, &cfg->ctx_err_recovery);
1206 ctxi->err_recovery_active = true;
1207 ctxi->ctrl_map = NULL;
1208 unmap_context(ctxi);
1209 mutex_unlock(&ctxi->mutex);
1210 }
1211 }
1212
1213 mutex_unlock(&cfg->ctx_tbl_list_mutex);
1214 return rc;
1215}
1216
1217/*
1218 * Dummy NULL fops
1219 */
1220static const struct file_operations null_fops = {
1221 .owner = THIS_MODULE,
1222};
1223
0a27ae51
MO
1224/**
1225 * check_state() - checks and responds to the current adapter state
1226 * @cfg: Internal structure associated with the host.
1227 *
1228 * This routine can block and should only be used on process context.
1229 * It assumes that the caller is an ioctl thread and holding the ioctl
1230 * read semaphore. This is temporarily let up across the wait to allow
1231 * for draining actively running ioctls. Also note that when waking up
1232 * from waiting in reset, the state is unknown and must be checked again
1233 * before proceeding.
1234 *
1235 * Return: 0 on success, -errno on failure
1236 */
aacb4ff6 1237int check_state(struct cxlflash_cfg *cfg)
0a27ae51
MO
1238{
1239 struct device *dev = &cfg->dev->dev;
1240 int rc = 0;
1241
1242retry:
1243 switch (cfg->state) {
439e85c1
MO
1244 case STATE_RESET:
1245 dev_dbg(dev, "%s: Reset state, going to wait...\n", __func__);
0a27ae51 1246 up_read(&cfg->ioctl_rwsem);
439e85c1
MO
1247 rc = wait_event_interruptible(cfg->reset_waitq,
1248 cfg->state != STATE_RESET);
0a27ae51
MO
1249 down_read(&cfg->ioctl_rwsem);
1250 if (unlikely(rc))
1251 break;
1252 goto retry;
1253 case STATE_FAILTERM:
1254 dev_dbg(dev, "%s: Failed/Terminating!\n", __func__);
1255 rc = -ENODEV;
1256 break;
1257 default:
1258 break;
1259 }
1260
1261 return rc;
1262}
1263
65be2c79
MO
1264/**
1265 * cxlflash_disk_attach() - attach a LUN to a context
1266 * @sdev: SCSI device associated with LUN.
1267 * @attach: Attach ioctl data structure.
1268 *
1269 * Creates a context and attaches LUN to it. A LUN can only be attached
1270 * one time to a context (subsequent attaches for the same context/LUN pair
1271 * are not supported). Additional LUNs can be attached to a context by
1272 * specifying the 'reuse' flag defined in the cxlflash_ioctl.h header.
1273 *
1274 * Return: 0 on success, -errno on failure
1275 */
1276static int cxlflash_disk_attach(struct scsi_device *sdev,
1277 struct dk_cxlflash_attach *attach)
1278{
1279 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
1280 struct device *dev = &cfg->dev->dev;
1281 struct afu *afu = cfg->afu;
1282 struct llun_info *lli = sdev->hostdata;
1283 struct glun_info *gli = lli->parent;
1284 struct cxl_ioctl_start_work *work;
1285 struct ctx_info *ctxi = NULL;
1286 struct lun_access *lun_access = NULL;
1287 int rc = 0;
1288 u32 perms;
1289 int ctxid = -1;
bae0ac69 1290 u64 flags = 0UL;
65be2c79 1291 u64 rctxid = 0UL;
8a96b52a 1292 struct file *file = NULL;
65be2c79 1293
8a96b52a 1294 struct cxl_context *ctx = NULL;
65be2c79
MO
1295
1296 int fd = -1;
1297
65be2c79
MO
1298 if (attach->num_interrupts > 4) {
1299 dev_dbg(dev, "%s: Cannot support this many interrupts %llu\n",
1300 __func__, attach->num_interrupts);
1301 rc = -EINVAL;
1302 goto out;
1303 }
1304
1305 if (gli->max_lba == 0) {
1306 dev_dbg(dev, "%s: No capacity info for this LUN (%016llX)\n",
1307 __func__, lli->lun_id[sdev->channel]);
1308 rc = read_cap16(sdev, lli);
1309 if (rc) {
1310 dev_err(dev, "%s: Invalid device! (%d)\n",
1311 __func__, rc);
1312 rc = -ENODEV;
1313 goto out;
1314 }
1315 dev_dbg(dev, "%s: LBA = %016llX\n", __func__, gli->max_lba);
1316 dev_dbg(dev, "%s: BLK_LEN = %08X\n", __func__, gli->blk_len);
1317 }
1318
1319 if (attach->hdr.flags & DK_CXLFLASH_ATTACH_REUSE_CONTEXT) {
1320 rctxid = attach->context_id;
1321 ctxi = get_context(cfg, rctxid, NULL, 0);
1322 if (!ctxi) {
1323 dev_dbg(dev, "%s: Bad context! (%016llX)\n",
1324 __func__, rctxid);
1325 rc = -EINVAL;
1326 goto out;
1327 }
1328
1329 list_for_each_entry(lun_access, &ctxi->luns, list)
1330 if (lun_access->lli == lli) {
1331 dev_dbg(dev, "%s: Already attached!\n",
1332 __func__);
1333 rc = -EINVAL;
1334 goto out;
1335 }
1336 }
1337
22fe1ae8
MO
1338 rc = scsi_device_get(sdev);
1339 if (unlikely(rc)) {
1340 dev_err(dev, "%s: Unable to get sdev reference!\n", __func__);
1341 goto out;
1342 }
1343
65be2c79
MO
1344 lun_access = kzalloc(sizeof(*lun_access), GFP_KERNEL);
1345 if (unlikely(!lun_access)) {
1346 dev_err(dev, "%s: Unable to allocate lun_access!\n", __func__);
1347 rc = -ENOMEM;
8a96b52a 1348 goto err;
65be2c79
MO
1349 }
1350
1351 lun_access->lli = lli;
1352 lun_access->sdev = sdev;
1353
888baf06 1354 /* Non-NULL context indicates reuse (another context reference) */
65be2c79
MO
1355 if (ctxi) {
1356 dev_dbg(dev, "%s: Reusing context for LUN! (%016llX)\n",
1357 __func__, rctxid);
888baf06 1358 kref_get(&ctxi->kref);
65be2c79 1359 list_add(&lun_access->list, &ctxi->luns);
65be2c79
MO
1360 goto out_attach;
1361 }
1362
5d1952ac
UK
1363 ctxi = create_context(cfg);
1364 if (unlikely(!ctxi)) {
1365 dev_err(dev, "%s: Failed to create context! (%d)\n",
1366 __func__, ctxid);
1367 goto err;
1368 }
1369
65be2c79 1370 ctx = cxl_dev_context_init(cfg->dev);
21891a45 1371 if (IS_ERR_OR_NULL(ctx)) {
65be2c79
MO
1372 dev_err(dev, "%s: Could not initialize context %p\n",
1373 __func__, ctx);
1374 rc = -ENODEV;
8a96b52a 1375 goto err;
65be2c79
MO
1376 }
1377
5d1952ac
UK
1378 work = &ctxi->work;
1379 work->num_interrupts = attach->num_interrupts;
1380 work->flags = CXL_START_WORK_NUM_IRQS;
1381
1382 rc = cxl_start_work(ctx, work);
1383 if (unlikely(rc)) {
1384 dev_dbg(dev, "%s: Could not start context rc=%d\n",
1385 __func__, rc);
1386 goto err;
1387 }
1388
65be2c79 1389 ctxid = cxl_process_element(ctx);
e37390be 1390 if (unlikely((ctxid >= MAX_CONTEXT) || (ctxid < 0))) {
65be2c79
MO
1391 dev_err(dev, "%s: ctxid (%d) invalid!\n", __func__, ctxid);
1392 rc = -EPERM;
8a96b52a 1393 goto err;
65be2c79
MO
1394 }
1395
1396 file = cxl_get_fd(ctx, &cfg->cxl_fops, &fd);
1397 if (unlikely(fd < 0)) {
1398 rc = -ENODEV;
1399 dev_err(dev, "%s: Could not get file descriptor\n", __func__);
8a96b52a 1400 goto err;
65be2c79
MO
1401 }
1402
1403 /* Translate read/write O_* flags from fcntl.h to AFU permission bits */
1404 perms = SISL_RHT_PERM(attach->hdr.flags + 1);
1405
5e6632d1 1406 /* Context mutex is locked upon return */
de9f0b0c 1407 init_context(ctxi, cfg, ctx, ctxid, file, perms);
5e6632d1 1408
65be2c79
MO
1409 rc = afu_attach(cfg, ctxi);
1410 if (unlikely(rc)) {
1411 dev_err(dev, "%s: Could not attach AFU rc %d\n", __func__, rc);
8a96b52a 1412 goto err;
65be2c79
MO
1413 }
1414
1415 /*
1416 * No error paths after this point. Once the fd is installed it's
1417 * visible to user space and can't be undone safely on this thread.
1418 * There is no need to worry about a deadlock here because no one
1419 * knows about us yet; we can be the only one holding our mutex.
1420 */
1421 list_add(&lun_access->list, &ctxi->luns);
65be2c79
MO
1422 mutex_lock(&cfg->ctx_tbl_list_mutex);
1423 mutex_lock(&ctxi->mutex);
1424 cfg->ctx_tbl[ctxid] = ctxi;
1425 mutex_unlock(&cfg->ctx_tbl_list_mutex);
1426 fd_install(fd, file);
1427
1428out_attach:
cd34af40 1429 if (fd != -1)
bae0ac69
MO
1430 flags |= DK_CXLFLASH_APP_CLOSE_ADAP_FD;
1431 if (afu_is_sq_cmd_mode(afu))
1432 flags |= DK_CXLFLASH_CONTEXT_SQ_CMD_MODE;
cd34af40 1433
bae0ac69 1434 attach->hdr.return_flags = flags;
65be2c79
MO
1435 attach->context_id = ctxi->ctxid;
1436 attach->block_size = gli->blk_len;
1437 attach->mmio_size = sizeof(afu->afu_map->hosts[0].harea);
1438 attach->last_lba = gli->max_lba;
471a5a60
MK
1439 attach->max_xfer = sdev->host->max_sectors * MAX_SECTOR_UNIT;
1440 attach->max_xfer /= gli->blk_len;
65be2c79
MO
1441
1442out:
1443 attach->adap_fd = fd;
1444
1445 if (ctxi)
1446 put_context(ctxi);
1447
1448 dev_dbg(dev, "%s: returning ctxid=%d fd=%d bs=%lld rc=%d llba=%lld\n",
1449 __func__, ctxid, fd, attach->block_size, rc, attach->last_lba);
1450 return rc;
1451
8a96b52a
MO
1452err:
1453 /* Cleanup CXL context; okay to 'stop' even if it was not started */
1454 if (!IS_ERR_OR_NULL(ctx)) {
1455 cxl_stop_context(ctx);
1456 cxl_release_context(ctx);
1457 ctx = NULL;
1458 }
1459
65be2c79
MO
1460 /*
1461 * Here, we're overriding the fops with a dummy all-NULL fops because
1462 * fput() calls the release fop, which will cause us to mistakenly
1463 * call into the CXL code. Rather than try to add yet more complexity
1464 * to that routine (cxlflash_cxl_release) we should try to fix the
1465 * issue here.
1466 */
8a96b52a
MO
1467 if (fd > 0) {
1468 file->f_op = &null_fops;
1469 fput(file);
1470 put_unused_fd(fd);
1471 fd = -1;
1472 file = NULL;
1473 }
1474
41b99e1a 1475 /* Cleanup our context */
8a96b52a
MO
1476 if (ctxi) {
1477 destroy_context(cfg, ctxi);
1478 ctxi = NULL;
1479 }
1480
65be2c79 1481 kfree(lun_access);
22fe1ae8 1482 scsi_device_put(sdev);
65be2c79
MO
1483 goto out;
1484}
1485
1486/**
1487 * recover_context() - recovers a context in error
1488 * @cfg: Internal structure associated with the host.
1489 * @ctxi: Context to release.
de9f0b0c 1490 * @adap_fd: Adapter file descriptor associated with new/recovered context.
65be2c79
MO
1491 *
1492 * Restablishes the state for a context-in-error.
1493 *
1494 * Return: 0 on success, -errno on failure
1495 */
de9f0b0c
MO
1496static int recover_context(struct cxlflash_cfg *cfg,
1497 struct ctx_info *ctxi,
1498 int *adap_fd)
65be2c79
MO
1499{
1500 struct device *dev = &cfg->dev->dev;
1501 int rc = 0;
cd34af40 1502 int fd = -1;
65be2c79
MO
1503 int ctxid = -1;
1504 struct file *file;
1505 struct cxl_context *ctx;
1506 struct afu *afu = cfg->afu;
1507
1508 ctx = cxl_dev_context_init(cfg->dev);
21891a45 1509 if (IS_ERR_OR_NULL(ctx)) {
65be2c79
MO
1510 dev_err(dev, "%s: Could not initialize context %p\n",
1511 __func__, ctx);
1512 rc = -ENODEV;
1513 goto out;
1514 }
1515
5d1952ac
UK
1516 rc = cxl_start_work(ctx, &ctxi->work);
1517 if (unlikely(rc)) {
1518 dev_dbg(dev, "%s: Could not start context rc=%d\n",
1519 __func__, rc);
1520 goto err1;
1521 }
1522
65be2c79 1523 ctxid = cxl_process_element(ctx);
e37390be 1524 if (unlikely((ctxid >= MAX_CONTEXT) || (ctxid < 0))) {
65be2c79
MO
1525 dev_err(dev, "%s: ctxid (%d) invalid!\n", __func__, ctxid);
1526 rc = -EPERM;
5d1952ac 1527 goto err2;
65be2c79
MO
1528 }
1529
1530 file = cxl_get_fd(ctx, &cfg->cxl_fops, &fd);
1531 if (unlikely(fd < 0)) {
1532 rc = -ENODEV;
1533 dev_err(dev, "%s: Could not get file descriptor\n", __func__);
65be2c79
MO
1534 goto err2;
1535 }
1536
1537 /* Update with new MMIO area based on updated context id */
1538 ctxi->ctrl_map = &afu->afu_map->ctrls[ctxid].ctrl;
1539
1540 rc = afu_attach(cfg, ctxi);
1541 if (rc) {
1542 dev_err(dev, "%s: Could not attach AFU rc %d\n", __func__, rc);
1543 goto err3;
1544 }
1545
1546 /*
1547 * No error paths after this point. Once the fd is installed it's
1548 * visible to user space and can't be undone safely on this thread.
1549 */
65be2c79 1550 ctxi->ctxid = ENCODE_CTXID(ctxi, ctxid);
65be2c79
MO
1551 ctxi->ctx = ctx;
1552 ctxi->file = file;
1553
1554 /*
1555 * Put context back in table (note the reinit of the context list);
1556 * we must first drop the context's mutex and then acquire it in
1557 * order with the table/list mutex to avoid a deadlock - safe to do
1558 * here because no one can find us at this moment in time.
1559 */
1560 mutex_unlock(&ctxi->mutex);
1561 mutex_lock(&cfg->ctx_tbl_list_mutex);
1562 mutex_lock(&ctxi->mutex);
1563 list_del_init(&ctxi->list);
1564 cfg->ctx_tbl[ctxid] = ctxi;
1565 mutex_unlock(&cfg->ctx_tbl_list_mutex);
1566 fd_install(fd, file);
de9f0b0c 1567 *adap_fd = fd;
65be2c79
MO
1568out:
1569 dev_dbg(dev, "%s: returning ctxid=%d fd=%d rc=%d\n",
1570 __func__, ctxid, fd, rc);
1571 return rc;
1572
1573err3:
65be2c79
MO
1574 fput(file);
1575 put_unused_fd(fd);
5d1952ac
UK
1576err2:
1577 cxl_stop_context(ctx);
65be2c79
MO
1578err1:
1579 cxl_release_context(ctx);
1580 goto out;
1581}
1582
65be2c79
MO
1583/**
1584 * cxlflash_afu_recover() - initiates AFU recovery
1585 * @sdev: SCSI device associated with LUN.
1586 * @recover: Recover ioctl data structure.
1587 *
1588 * Only a single recovery is allowed at a time to avoid exhausting CXL
1589 * resources (leading to recovery failure) in the event that we're up
1590 * against the maximum number of contexts limit. For similar reasons,
1591 * a context recovery is retried if there are multiple recoveries taking
1592 * place at the same time and the failure was due to CXL services being
1593 * unable to keep up.
1594 *
635f6b08
MK
1595 * As this routine is called on ioctl context, it holds the ioctl r/w
1596 * semaphore that is used to drain ioctls in recovery scenarios. The
1597 * implementation to achieve the pacing described above (a local mutex)
1598 * requires that the ioctl r/w semaphore be dropped and reacquired to
1599 * avoid a 3-way deadlock when multiple process recoveries operate in
1600 * parallel.
1601 *
65be2c79
MO
1602 * Because a user can detect an error condition before the kernel, it is
1603 * quite possible for this routine to act as the kernel's EEH detection
1604 * source (MMIO read of mbox_r). Because of this, there is a window of
1605 * time where an EEH might have been detected but not yet 'serviced'
439e85c1 1606 * (callback invoked, causing the device to enter reset state). To avoid
65be2c79
MO
1607 * looping in this routine during that window, a 1 second sleep is in place
1608 * between the time the MMIO failure is detected and the time a wait on the
439e85c1 1609 * reset wait queue is attempted via check_state().
65be2c79
MO
1610 *
1611 * Return: 0 on success, -errno on failure
1612 */
1613static int cxlflash_afu_recover(struct scsi_device *sdev,
1614 struct dk_cxlflash_recover_afu *recover)
1615{
1616 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
1617 struct device *dev = &cfg->dev->dev;
1618 struct llun_info *lli = sdev->hostdata;
1619 struct afu *afu = cfg->afu;
1620 struct ctx_info *ctxi = NULL;
1621 struct mutex *mutex = &cfg->ctx_recovery_mutex;
bae0ac69 1622 u64 flags;
65be2c79
MO
1623 u64 ctxid = DECODE_CTXID(recover->context_id),
1624 rctxid = recover->context_id;
1625 long reg;
1626 int lretry = 20; /* up to 2 seconds */
de9f0b0c 1627 int new_adap_fd = -1;
65be2c79
MO
1628 int rc = 0;
1629
1630 atomic_inc(&cfg->recovery_threads);
635f6b08 1631 up_read(&cfg->ioctl_rwsem);
65be2c79 1632 rc = mutex_lock_interruptible(mutex);
635f6b08 1633 down_read(&cfg->ioctl_rwsem);
65be2c79
MO
1634 if (rc)
1635 goto out;
635f6b08
MK
1636 rc = check_state(cfg);
1637 if (rc) {
1638 dev_err(dev, "%s: Failed state! rc=%d\n", __func__, rc);
1639 rc = -ENODEV;
1640 goto out;
1641 }
65be2c79
MO
1642
1643 dev_dbg(dev, "%s: reason 0x%016llX rctxid=%016llX\n",
1644 __func__, recover->reason, rctxid);
1645
1646retry:
1647 /* Ensure that this process is attached to the context */
1648 ctxi = get_context(cfg, rctxid, lli, CTX_CTRL_ERR_FALLBACK);
1649 if (unlikely(!ctxi)) {
1650 dev_dbg(dev, "%s: Bad context! (%llu)\n", __func__, ctxid);
1651 rc = -EINVAL;
1652 goto out;
1653 }
1654
1655 if (ctxi->err_recovery_active) {
1656retry_recover:
de9f0b0c 1657 rc = recover_context(cfg, ctxi, &new_adap_fd);
65be2c79
MO
1658 if (unlikely(rc)) {
1659 dev_err(dev, "%s: Recovery failed for context %llu (rc=%d)\n",
1660 __func__, ctxid, rc);
1661 if ((rc == -ENODEV) &&
1662 ((atomic_read(&cfg->recovery_threads) > 1) ||
1663 (lretry--))) {
1664 dev_dbg(dev, "%s: Going to try again!\n",
1665 __func__);
1666 mutex_unlock(mutex);
1667 msleep(100);
1668 rc = mutex_lock_interruptible(mutex);
1669 if (rc)
1670 goto out;
1671 goto retry_recover;
1672 }
1673
1674 goto out;
1675 }
1676
1677 ctxi->err_recovery_active = false;
bae0ac69
MO
1678
1679 flags = DK_CXLFLASH_APP_CLOSE_ADAP_FD |
1680 DK_CXLFLASH_RECOVER_AFU_CONTEXT_RESET;
1681 if (afu_is_sq_cmd_mode(afu))
1682 flags |= DK_CXLFLASH_CONTEXT_SQ_CMD_MODE;
1683
1684 recover->hdr.return_flags = flags;
65be2c79 1685 recover->context_id = ctxi->ctxid;
de9f0b0c 1686 recover->adap_fd = new_adap_fd;
65be2c79 1687 recover->mmio_size = sizeof(afu->afu_map->hosts[0].harea);
65be2c79
MO
1688 goto out;
1689 }
1690
1691 /* Test if in error state */
1692 reg = readq_be(&afu->ctrl_map->mbox_r);
1693 if (reg == -1) {
0a27ae51
MO
1694 dev_dbg(dev, "%s: MMIO fail, wait for recovery.\n", __func__);
1695
1696 /*
1697 * Before checking the state, put back the context obtained with
1698 * get_context() as it is no longer needed and sleep for a short
1699 * period of time (see prolog notes).
1700 */
1701 put_context(ctxi);
65be2c79
MO
1702 ctxi = NULL;
1703 ssleep(1);
1704 rc = check_state(cfg);
1705 if (unlikely(rc))
1706 goto out;
1707 goto retry;
1708 }
1709
1710 dev_dbg(dev, "%s: MMIO working, no recovery required!\n", __func__);
1711out:
1712 if (likely(ctxi))
1713 put_context(ctxi);
1714 mutex_unlock(mutex);
1715 atomic_dec_if_positive(&cfg->recovery_threads);
1716 return rc;
1717}
1718
1719/**
1720 * process_sense() - evaluates and processes sense data
1721 * @sdev: SCSI device associated with LUN.
1722 * @verify: Verify ioctl data structure.
1723 *
1724 * Return: 0 on success, -errno on failure
1725 */
1726static int process_sense(struct scsi_device *sdev,
1727 struct dk_cxlflash_verify *verify)
1728{
1729 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
1730 struct device *dev = &cfg->dev->dev;
1731 struct llun_info *lli = sdev->hostdata;
1732 struct glun_info *gli = lli->parent;
1733 u64 prev_lba = gli->max_lba;
1734 struct scsi_sense_hdr sshdr = { 0 };
1735 int rc = 0;
1736
1737 rc = scsi_normalize_sense((const u8 *)&verify->sense_data,
1738 DK_CXLFLASH_VERIFY_SENSE_LEN, &sshdr);
1739 if (!rc) {
1740 dev_err(dev, "%s: Failed to normalize sense data!\n", __func__);
1741 rc = -EINVAL;
1742 goto out;
1743 }
1744
1745 switch (sshdr.sense_key) {
1746 case NO_SENSE:
1747 case RECOVERED_ERROR:
1748 /* fall through */
1749 case NOT_READY:
1750 break;
1751 case UNIT_ATTENTION:
1752 switch (sshdr.asc) {
1753 case 0x29: /* Power on Reset or Device Reset */
1754 /* fall through */
1755 case 0x2A: /* Device settings/capacity changed */
1756 rc = read_cap16(sdev, lli);
1757 if (rc) {
1758 rc = -ENODEV;
1759 break;
1760 }
1761 if (prev_lba != gli->max_lba)
1762 dev_dbg(dev, "%s: Capacity changed old=%lld "
1763 "new=%lld\n", __func__, prev_lba,
1764 gli->max_lba);
1765 break;
1766 case 0x3F: /* Report LUNs changed, Rescan. */
1767 scsi_scan_host(cfg->host);
1768 break;
1769 default:
1770 rc = -EIO;
1771 break;
1772 }
1773 break;
1774 default:
1775 rc = -EIO;
1776 break;
1777 }
1778out:
1779 dev_dbg(dev, "%s: sense_key %x asc %x ascq %x rc %d\n", __func__,
1780 sshdr.sense_key, sshdr.asc, sshdr.ascq, rc);
1781 return rc;
1782}
1783
1784/**
1785 * cxlflash_disk_verify() - verifies a LUN is the same and handle size changes
1786 * @sdev: SCSI device associated with LUN.
1787 * @verify: Verify ioctl data structure.
1788 *
1789 * Return: 0 on success, -errno on failure
1790 */
1791static int cxlflash_disk_verify(struct scsi_device *sdev,
1792 struct dk_cxlflash_verify *verify)
1793{
1794 int rc = 0;
1795 struct ctx_info *ctxi = NULL;
1796 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
1797 struct device *dev = &cfg->dev->dev;
1798 struct llun_info *lli = sdev->hostdata;
1799 struct glun_info *gli = lli->parent;
1800 struct sisl_rht_entry *rhte = NULL;
1801 res_hndl_t rhndl = verify->rsrc_handle;
1802 u64 ctxid = DECODE_CTXID(verify->context_id),
1803 rctxid = verify->context_id;
1804 u64 last_lba = 0;
1805
1806 dev_dbg(dev, "%s: ctxid=%llu rhndl=%016llX, hint=%016llX, "
1807 "flags=%016llX\n", __func__, ctxid, verify->rsrc_handle,
1808 verify->hint, verify->hdr.flags);
1809
1810 ctxi = get_context(cfg, rctxid, lli, 0);
1811 if (unlikely(!ctxi)) {
1812 dev_dbg(dev, "%s: Bad context! (%llu)\n", __func__, ctxid);
1813 rc = -EINVAL;
1814 goto out;
1815 }
1816
1817 rhte = get_rhte(ctxi, rhndl, lli);
1818 if (unlikely(!rhte)) {
1819 dev_dbg(dev, "%s: Bad resource handle! (%d)\n",
1820 __func__, rhndl);
1821 rc = -EINVAL;
1822 goto out;
1823 }
1824
1825 /*
1826 * Look at the hint/sense to see if it requires us to redrive
1827 * inquiry (i.e. the Unit attention is due to the WWN changing).
1828 */
1829 if (verify->hint & DK_CXLFLASH_VERIFY_HINT_SENSE) {
8e782623
MO
1830 /* Can't hold mutex across process_sense/read_cap16,
1831 * since we could have an intervening EEH event.
1832 */
1833 ctxi->unavail = true;
1834 mutex_unlock(&ctxi->mutex);
65be2c79
MO
1835 rc = process_sense(sdev, verify);
1836 if (unlikely(rc)) {
1837 dev_err(dev, "%s: Failed to validate sense data (%d)\n",
1838 __func__, rc);
8e782623
MO
1839 mutex_lock(&ctxi->mutex);
1840 ctxi->unavail = false;
65be2c79
MO
1841 goto out;
1842 }
8e782623
MO
1843 mutex_lock(&ctxi->mutex);
1844 ctxi->unavail = false;
65be2c79
MO
1845 }
1846
1847 switch (gli->mode) {
1848 case MODE_PHYSICAL:
1849 last_lba = gli->max_lba;
1850 break;
2cb79266
MO
1851 case MODE_VIRTUAL:
1852 /* Cast lxt_cnt to u64 for multiply to be treated as 64bit op */
1853 last_lba = ((u64)rhte->lxt_cnt * MC_CHUNK_SIZE * gli->blk_len);
1854 last_lba /= CXLFLASH_BLOCK_SIZE;
1855 last_lba--;
1856 break;
65be2c79
MO
1857 default:
1858 WARN(1, "Unsupported LUN mode!");
1859 }
1860
1861 verify->last_lba = last_lba;
1862
1863out:
1864 if (likely(ctxi))
1865 put_context(ctxi);
1866 dev_dbg(dev, "%s: returning rc=%d llba=%llX\n",
1867 __func__, rc, verify->last_lba);
1868 return rc;
1869}
1870
1871/**
1872 * decode_ioctl() - translates an encoded ioctl to an easily identifiable string
1873 * @cmd: The ioctl command to decode.
1874 *
1875 * Return: A string identifying the decoded ioctl.
1876 */
1877static char *decode_ioctl(int cmd)
1878{
1879 switch (cmd) {
1880 case DK_CXLFLASH_ATTACH:
1881 return __stringify_1(DK_CXLFLASH_ATTACH);
1882 case DK_CXLFLASH_USER_DIRECT:
1883 return __stringify_1(DK_CXLFLASH_USER_DIRECT);
2cb79266
MO
1884 case DK_CXLFLASH_USER_VIRTUAL:
1885 return __stringify_1(DK_CXLFLASH_USER_VIRTUAL);
1886 case DK_CXLFLASH_VLUN_RESIZE:
1887 return __stringify_1(DK_CXLFLASH_VLUN_RESIZE);
65be2c79
MO
1888 case DK_CXLFLASH_RELEASE:
1889 return __stringify_1(DK_CXLFLASH_RELEASE);
1890 case DK_CXLFLASH_DETACH:
1891 return __stringify_1(DK_CXLFLASH_DETACH);
1892 case DK_CXLFLASH_VERIFY:
1893 return __stringify_1(DK_CXLFLASH_VERIFY);
2cb79266
MO
1894 case DK_CXLFLASH_VLUN_CLONE:
1895 return __stringify_1(DK_CXLFLASH_VLUN_CLONE);
65be2c79
MO
1896 case DK_CXLFLASH_RECOVER_AFU:
1897 return __stringify_1(DK_CXLFLASH_RECOVER_AFU);
1898 case DK_CXLFLASH_MANAGE_LUN:
1899 return __stringify_1(DK_CXLFLASH_MANAGE_LUN);
1900 }
1901
1902 return "UNKNOWN";
1903}
1904
1905/**
1906 * cxlflash_disk_direct_open() - opens a direct (physical) disk
1907 * @sdev: SCSI device associated with LUN.
1908 * @arg: UDirect ioctl data structure.
1909 *
1910 * On successful return, the user is informed of the resource handle
1911 * to be used to identify the direct lun and the size (in blocks) of
1912 * the direct lun in last LBA format.
1913 *
1914 * Return: 0 on success, -errno on failure
1915 */
1916static int cxlflash_disk_direct_open(struct scsi_device *sdev, void *arg)
1917{
1918 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
1919 struct device *dev = &cfg->dev->dev;
1920 struct afu *afu = cfg->afu;
1921 struct llun_info *lli = sdev->hostdata;
1922 struct glun_info *gli = lli->parent;
1923
1924 struct dk_cxlflash_udirect *pphys = (struct dk_cxlflash_udirect *)arg;
1925
1926 u64 ctxid = DECODE_CTXID(pphys->context_id),
1927 rctxid = pphys->context_id;
1928 u64 lun_size = 0;
1929 u64 last_lba = 0;
1930 u64 rsrc_handle = -1;
1931 u32 port = CHAN2PORT(sdev->channel);
1932
1933 int rc = 0;
1934
1935 struct ctx_info *ctxi = NULL;
1936 struct sisl_rht_entry *rhte = NULL;
1937
1938 pr_debug("%s: ctxid=%llu ls=0x%llx\n", __func__, ctxid, lun_size);
1939
1940 rc = cxlflash_lun_attach(gli, MODE_PHYSICAL, false);
1941 if (unlikely(rc)) {
1942 dev_dbg(dev, "%s: Failed to attach to LUN! (PHYSICAL)\n",
1943 __func__);
1944 goto out;
1945 }
1946
1947 ctxi = get_context(cfg, rctxid, lli, 0);
1948 if (unlikely(!ctxi)) {
1949 dev_dbg(dev, "%s: Bad context! (%llu)\n", __func__, ctxid);
1950 rc = -EINVAL;
1951 goto err1;
1952 }
1953
1954 rhte = rhte_checkout(ctxi, lli);
1955 if (unlikely(!rhte)) {
1956 dev_dbg(dev, "%s: too many opens for this context\n", __func__);
1957 rc = -EMFILE; /* too many opens */
1958 goto err1;
1959 }
1960
1961 rsrc_handle = (rhte - ctxi->rht_start);
1962
1963 rht_format1(rhte, lli->lun_id[sdev->channel], ctxi->rht_perms, port);
1964 cxlflash_afu_sync(afu, ctxid, rsrc_handle, AFU_LW_SYNC);
1965
1966 last_lba = gli->max_lba;
1967 pphys->hdr.return_flags = 0;
1968 pphys->last_lba = last_lba;
1969 pphys->rsrc_handle = rsrc_handle;
1970
1971out:
1972 if (likely(ctxi))
1973 put_context(ctxi);
1974 dev_dbg(dev, "%s: returning handle 0x%llx rc=%d llba %lld\n",
1975 __func__, rsrc_handle, rc, last_lba);
1976 return rc;
1977
1978err1:
1979 cxlflash_lun_detach(gli);
1980 goto out;
1981}
1982
1983/**
1984 * ioctl_common() - common IOCTL handler for driver
1985 * @sdev: SCSI device associated with LUN.
1986 * @cmd: IOCTL command.
1987 *
1988 * Handles common fencing operations that are valid for multiple ioctls. Always
1989 * allow through ioctls that are cleanup oriented in nature, even when operating
1990 * in a failed/terminating state.
1991 *
1992 * Return: 0 on success, -errno on failure
1993 */
1994static int ioctl_common(struct scsi_device *sdev, int cmd)
1995{
1996 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
1997 struct device *dev = &cfg->dev->dev;
1998 struct llun_info *lli = sdev->hostdata;
1999 int rc = 0;
2000
2001 if (unlikely(!lli)) {
2002 dev_dbg(dev, "%s: Unknown LUN\n", __func__);
2003 rc = -EINVAL;
2004 goto out;
2005 }
2006
2007 rc = check_state(cfg);
2008 if (unlikely(rc) && (cfg->state == STATE_FAILTERM)) {
2009 switch (cmd) {
2cb79266 2010 case DK_CXLFLASH_VLUN_RESIZE:
65be2c79
MO
2011 case DK_CXLFLASH_RELEASE:
2012 case DK_CXLFLASH_DETACH:
2013 dev_dbg(dev, "%s: Command override! (%d)\n",
2014 __func__, rc);
2015 rc = 0;
2016 break;
2017 }
2018 }
2019out:
2020 return rc;
2021}
2022
2023/**
2024 * cxlflash_ioctl() - IOCTL handler for driver
2025 * @sdev: SCSI device associated with LUN.
2026 * @cmd: IOCTL command.
2027 * @arg: Userspace ioctl data structure.
2028 *
0a27ae51
MO
2029 * A read/write semaphore is used to implement a 'drain' of currently
2030 * running ioctls. The read semaphore is taken at the beginning of each
2031 * ioctl thread and released upon concluding execution. Additionally the
2032 * semaphore should be released and then reacquired in any ioctl execution
2033 * path which will wait for an event to occur that is outside the scope of
2034 * the ioctl (i.e. an adapter reset). To drain the ioctls currently running,
2035 * a thread simply needs to acquire the write semaphore.
2036 *
65be2c79
MO
2037 * Return: 0 on success, -errno on failure
2038 */
2039int cxlflash_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
2040{
2041 typedef int (*sioctl) (struct scsi_device *, void *);
2042
2043 struct cxlflash_cfg *cfg = (struct cxlflash_cfg *)sdev->host->hostdata;
2044 struct device *dev = &cfg->dev->dev;
2045 struct afu *afu = cfg->afu;
2046 struct dk_cxlflash_hdr *hdr;
2047 char buf[sizeof(union cxlflash_ioctls)];
2048 size_t size = 0;
2049 bool known_ioctl = false;
2050 int idx;
2051 int rc = 0;
2052 struct Scsi_Host *shost = sdev->host;
2053 sioctl do_ioctl = NULL;
2054
2055 static const struct {
2056 size_t size;
2057 sioctl ioctl;
2058 } ioctl_tbl[] = { /* NOTE: order matters here */
2059 {sizeof(struct dk_cxlflash_attach), (sioctl)cxlflash_disk_attach},
2060 {sizeof(struct dk_cxlflash_udirect), cxlflash_disk_direct_open},
2061 {sizeof(struct dk_cxlflash_release), (sioctl)cxlflash_disk_release},
2062 {sizeof(struct dk_cxlflash_detach), (sioctl)cxlflash_disk_detach},
2063 {sizeof(struct dk_cxlflash_verify), (sioctl)cxlflash_disk_verify},
2064 {sizeof(struct dk_cxlflash_recover_afu), (sioctl)cxlflash_afu_recover},
2065 {sizeof(struct dk_cxlflash_manage_lun), (sioctl)cxlflash_manage_lun},
2cb79266
MO
2066 {sizeof(struct dk_cxlflash_uvirtual), cxlflash_disk_virtual_open},
2067 {sizeof(struct dk_cxlflash_resize), (sioctl)cxlflash_vlun_resize},
2068 {sizeof(struct dk_cxlflash_clone), (sioctl)cxlflash_disk_clone},
65be2c79
MO
2069 };
2070
0a27ae51
MO
2071 /* Hold read semaphore so we can drain if needed */
2072 down_read(&cfg->ioctl_rwsem);
2073
65be2c79
MO
2074 /* Restrict command set to physical support only for internal LUN */
2075 if (afu->internal_lun)
2076 switch (cmd) {
2077 case DK_CXLFLASH_RELEASE:
2cb79266
MO
2078 case DK_CXLFLASH_USER_VIRTUAL:
2079 case DK_CXLFLASH_VLUN_RESIZE:
2080 case DK_CXLFLASH_VLUN_CLONE:
65be2c79
MO
2081 dev_dbg(dev, "%s: %s not supported for lun_mode=%d\n",
2082 __func__, decode_ioctl(cmd), afu->internal_lun);
2083 rc = -EINVAL;
2084 goto cxlflash_ioctl_exit;
2085 }
2086
2087 switch (cmd) {
2088 case DK_CXLFLASH_ATTACH:
2089 case DK_CXLFLASH_USER_DIRECT:
2090 case DK_CXLFLASH_RELEASE:
2091 case DK_CXLFLASH_DETACH:
2092 case DK_CXLFLASH_VERIFY:
2093 case DK_CXLFLASH_RECOVER_AFU:
2cb79266
MO
2094 case DK_CXLFLASH_USER_VIRTUAL:
2095 case DK_CXLFLASH_VLUN_RESIZE:
2096 case DK_CXLFLASH_VLUN_CLONE:
65be2c79
MO
2097 dev_dbg(dev, "%s: %s (%08X) on dev(%d/%d/%d/%llu)\n",
2098 __func__, decode_ioctl(cmd), cmd, shost->host_no,
2099 sdev->channel, sdev->id, sdev->lun);
2100 rc = ioctl_common(sdev, cmd);
2101 if (unlikely(rc))
2102 goto cxlflash_ioctl_exit;
2103
2104 /* fall through */
2105
2106 case DK_CXLFLASH_MANAGE_LUN:
2107 known_ioctl = true;
2108 idx = _IOC_NR(cmd) - _IOC_NR(DK_CXLFLASH_ATTACH);
2109 size = ioctl_tbl[idx].size;
2110 do_ioctl = ioctl_tbl[idx].ioctl;
2111
2112 if (likely(do_ioctl))
2113 break;
2114
2115 /* fall through */
2116 default:
2117 rc = -EINVAL;
2118 goto cxlflash_ioctl_exit;
2119 }
2120
2121 if (unlikely(copy_from_user(&buf, arg, size))) {
2122 dev_err(dev, "%s: copy_from_user() fail! "
2123 "size=%lu cmd=%d (%s) arg=%p\n",
2124 __func__, size, cmd, decode_ioctl(cmd), arg);
2125 rc = -EFAULT;
2126 goto cxlflash_ioctl_exit;
2127 }
2128
2129 hdr = (struct dk_cxlflash_hdr *)&buf;
2130 if (hdr->version != DK_CXLFLASH_VERSION_0) {
2131 dev_dbg(dev, "%s: Version %u not supported for %s\n",
2132 __func__, hdr->version, decode_ioctl(cmd));
2133 rc = -EINVAL;
2134 goto cxlflash_ioctl_exit;
2135 }
2136
2137 if (hdr->rsvd[0] || hdr->rsvd[1] || hdr->rsvd[2] || hdr->return_flags) {
2138 dev_dbg(dev, "%s: Reserved/rflags populated!\n", __func__);
2139 rc = -EINVAL;
2140 goto cxlflash_ioctl_exit;
2141 }
2142
2143 rc = do_ioctl(sdev, (void *)&buf);
2144 if (likely(!rc))
2145 if (unlikely(copy_to_user(arg, &buf, size))) {
2146 dev_err(dev, "%s: copy_to_user() fail! "
2147 "size=%lu cmd=%d (%s) arg=%p\n",
2148 __func__, size, cmd, decode_ioctl(cmd), arg);
2149 rc = -EFAULT;
2150 }
2151
2152 /* fall through to exit */
2153
2154cxlflash_ioctl_exit:
0a27ae51 2155 up_read(&cfg->ioctl_rwsem);
65be2c79
MO
2156 if (unlikely(rc && known_ioctl))
2157 dev_err(dev, "%s: ioctl %s (%08X) on dev(%d/%d/%d/%llu) "
2158 "returned rc %d\n", __func__,
2159 decode_ioctl(cmd), cmd, shost->host_no,
2160 sdev->channel, sdev->id, sdev->lun, rc);
2161 else
2162 dev_dbg(dev, "%s: ioctl %s (%08X) on dev(%d/%d/%d/%llu) "
2163 "returned rc %d\n", __func__, decode_ioctl(cmd),
2164 cmd, shost->host_no, sdev->channel, sdev->id,
2165 sdev->lun, rc);
2166 return rc;
2167}