root/drivers/scsi/cxlflash/lunmgt.c

DEFINITIONS

1. create_local
2. create_global
3. lookup_local
4. lookup_global
5. find_and_create_lun
6. cxlflash_term_local_luns
7. cxlflash_list_init
8. cxlflash_term_global_luns
9. cxlflash_manage_lun

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