LXR linux/drivers/gpu/drm/amd/amdkfd/kfd_process_queue

   1/*
   2 * Copyright 2014 Advanced Micro Devices, Inc.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice shall be included in
  12 * all copies or substantial portions of the Software.
  13 *
  14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20 * OTHER DEALINGS IN THE SOFTWARE.
  21 *
  22 */
  23
  24#include <linux/slab.h>
  25#include <linux/list.h>
  26#include "kfd_device_queue_manager.h"
  27#include "kfd_priv.h"
  28#include "kfd_kernel_queue.h"
  29
  30static inline struct process_queue_node *get_queue_by_qid(
  31                        struct process_queue_manager *pqm, unsigned int qid)
  32{
  33        struct process_queue_node *pqn;
  34
  35        BUG_ON(!pqm);
  36
  37        list_for_each_entry(pqn, &pqm->queues, process_queue_list) {
  38                if (pqn->q && pqn->q->properties.queue_id == qid)
  39                        return pqn;
  40                if (pqn->kq && pqn->kq->queue->properties.queue_id == qid)
  41                        return pqn;
  42        }
  43
  44        return NULL;
  45}
  46
  47static int find_available_queue_slot(struct process_queue_manager *pqm,
  48                                        unsigned int *qid)
  49{
  50        unsigned long found;
  51
  52        BUG_ON(!pqm || !qid);
  53
  54        pr_debug("kfd: in %s\n", __func__);
  55
  56        found = find_first_zero_bit(pqm->queue_slot_bitmap,
  57                        KFD_MAX_NUM_OF_QUEUES_PER_PROCESS);
  58
  59        pr_debug("kfd: the new slot id %lu\n", found);
  60
  61        if (found >= KFD_MAX_NUM_OF_QUEUES_PER_PROCESS) {
  62                pr_info("amdkfd: Can not open more queues for process with pasid %d\n",
  63                                pqm->process->pasid);
  64                return -ENOMEM;
  65        }
  66
  67        set_bit(found, pqm->queue_slot_bitmap);
  68        *qid = found;
  69
  70        return 0;
  71}
  72
  73int pqm_init(struct process_queue_manager *pqm, struct kfd_process *p)
  74{
  75        BUG_ON(!pqm);
  76
  77        INIT_LIST_HEAD(&pqm->queues);
  78        pqm->queue_slot_bitmap =
  79                        kzalloc(DIV_ROUND_UP(KFD_MAX_NUM_OF_QUEUES_PER_PROCESS,
  80                                        BITS_PER_BYTE), GFP_KERNEL);
  81        if (pqm->queue_slot_bitmap == NULL)
  82                return -ENOMEM;
  83        pqm->process = p;
  84
  85        return 0;
  86}
  87
  88void pqm_uninit(struct process_queue_manager *pqm)
  89{
  90        int retval;
  91        struct process_queue_node *pqn, *next;
  92
  93        BUG_ON(!pqm);
  94
  95        pr_debug("In func %s\n", __func__);
  96
  97        list_for_each_entry_safe(pqn, next, &pqm->queues, process_queue_list) {
  98                retval = pqm_destroy_queue(
  99                                pqm,
 100                                (pqn->q != NULL) ?
 101                                        pqn->q->properties.queue_id :
 102                                        pqn->kq->queue->properties.queue_id);
 103
 104                if (retval != 0) {
 105                        pr_err("kfd: failed to destroy queue\n");
 106                        return;
 107                }
 108        }
 109        kfree(pqm->queue_slot_bitmap);
 110        pqm->queue_slot_bitmap = NULL;
 111}
 112
 113static int create_cp_queue(struct process_queue_manager *pqm,
 114                                struct kfd_dev *dev, struct queue **q,
 115                                struct queue_properties *q_properties,
 116                                struct file *f, unsigned int qid)
 117{
 118        int retval;
 119
 120        retval = 0;
 121
 122        /* Doorbell initialized in user space*/
 123        q_properties->doorbell_ptr = NULL;
 124
 125        q_properties->doorbell_off =
 126                        kfd_queue_id_to_doorbell(dev, pqm->process, qid);
 127
 128        /* let DQM handle it*/
 129        q_properties->vmid = 0;
 130        q_properties->queue_id = qid;
 131
 132        retval = init_queue(q, q_properties);
 133        if (retval != 0)
 134                goto err_init_queue;
 135
 136        (*q)->device = dev;
 137        (*q)->process = pqm->process;
 138
 139        pr_debug("kfd: PQM After init queue");
 140
 141        return retval;
 142
 143err_init_queue:
 144        return retval;
 145}
 146
 147int pqm_create_queue(struct process_queue_manager *pqm,
 148                            struct kfd_dev *dev,
 149                            struct file *f,
 150                            struct queue_properties *properties,
 151                            unsigned int flags,
 152                            enum kfd_queue_type type,
 153                            unsigned int *qid)
 154{
 155        int retval;
 156        struct kfd_process_device *pdd;
 157        struct queue_properties q_properties;
 158        struct queue *q;
 159        struct process_queue_node *pqn;
 160        struct kernel_queue *kq;
 161        int num_queues = 0;
 162        struct queue *cur;
 163
 164        BUG_ON(!pqm || !dev || !properties || !qid);
 165
 166        memset(&q_properties, 0, sizeof(struct queue_properties));
 167        memcpy(&q_properties, properties, sizeof(struct queue_properties));
 168        q = NULL;
 169        kq = NULL;
 170
 171        pdd = kfd_get_process_device_data(dev, pqm->process);
 172        if (!pdd) {
 173                pr_err("Process device data doesn't exist\n");
 174                return -1;
 175        }
 176
 177        /*
 178         * for debug process, verify that it is within the static queues limit
 179         * currently limit is set to half of the total avail HQD slots
 180         * If we are just about to create DIQ, the is_debug flag is not set yet
 181         * Hence we also check the type as well
 182         */
 183        if ((pdd->qpd.is_debug) ||
 184                (type == KFD_QUEUE_TYPE_DIQ)) {
 185                list_for_each_entry(cur, &pdd->qpd.queues_list, list)
 186                        num_queues++;
 187                if (num_queues >= dev->device_info->max_no_of_hqd/2)
 188                        return (-ENOSPC);
 189        }
 190
 191        retval = find_available_queue_slot(pqm, qid);
 192        if (retval != 0)
 193                return retval;
 194
 195        if (list_empty(&pqm->queues)) {
 196                pdd->qpd.pqm = pqm;
 197                dev->dqm->ops.register_process(dev->dqm, &pdd->qpd);
 198        }
 199
 200        pqn = kzalloc(sizeof(struct process_queue_node), GFP_KERNEL);
 201        if (!pqn) {
 202                retval = -ENOMEM;
 203                goto err_allocate_pqn;
 204        }
 205
 206        switch (type) {
 207        case KFD_QUEUE_TYPE_SDMA:
 208        case KFD_QUEUE_TYPE_COMPUTE:
 209                /* check if there is over subscription */
 210                if ((sched_policy == KFD_SCHED_POLICY_HWS_NO_OVERSUBSCRIPTION) &&
 211                ((dev->dqm->processes_count >= VMID_PER_DEVICE) ||
 212                (dev->dqm->queue_count >= get_queues_num(dev->dqm)))) {
 213                        pr_err("kfd: over-subscription is not allowed in radeon_kfd.sched_policy == 1\n");
 214                        retval = -EPERM;
 215                        goto err_create_queue;
 216                }
 217
 218                retval = create_cp_queue(pqm, dev, &q, &q_properties, f, *qid);
 219                if (retval != 0)
 220                        goto err_create_queue;
 221                pqn->q = q;
 222                pqn->kq = NULL;
 223                retval = dev->dqm->ops.create_queue(dev->dqm, q, &pdd->qpd,
 224                                                &q->properties.vmid);
 225                pr_debug("DQM returned %d for create_queue\n", retval);
 226                print_queue(q);
 227                break;
 228        case KFD_QUEUE_TYPE_DIQ:
 229                kq = kernel_queue_init(dev, KFD_QUEUE_TYPE_DIQ);
 230                if (kq == NULL) {
 231                        retval = -ENOMEM;
 232                        goto err_create_queue;
 233                }
 234                kq->queue->properties.queue_id = *qid;
 235                pqn->kq = kq;
 236                pqn->q = NULL;
 237                retval = dev->dqm->ops.create_kernel_queue(dev->dqm,
 238                                                        kq, &pdd->qpd);
 239                break;
 240        default:
 241                BUG();
 242                break;
 243        }
 244
 245        if (retval != 0) {
 246                pr_debug("Error dqm create queue\n");
 247                goto err_create_queue;
 248        }
 249
 250        pr_debug("kfd: PQM After DQM create queue\n");
 251
 252        list_add(&pqn->process_queue_list, &pqm->queues);
 253
 254        if (q) {
 255                *properties = q->properties;
 256                pr_debug("kfd: PQM done creating queue\n");
 257                print_queue_properties(properties);
 258        }
 259
 260        return retval;
 261
 262err_create_queue:
 263        kfree(pqn);
 264err_allocate_pqn:
 265        /* check if queues list is empty unregister process from device */
 266        clear_bit(*qid, pqm->queue_slot_bitmap);
 267        if (list_empty(&pqm->queues))
 268                dev->dqm->ops.unregister_process(dev->dqm, &pdd->qpd);
 269        return retval;
 270}
 271
 272int pqm_destroy_queue(struct process_queue_manager *pqm, unsigned int qid)
 273{
 274        struct process_queue_node *pqn;
 275        struct kfd_process_device *pdd;
 276        struct device_queue_manager *dqm;
 277        struct kfd_dev *dev;
 278        int retval;
 279
 280        dqm = NULL;
 281
 282        BUG_ON(!pqm);
 283        retval = 0;
 284
 285        pr_debug("kfd: In Func %s\n", __func__);
 286
 287        pqn = get_queue_by_qid(pqm, qid);
 288        if (pqn == NULL) {
 289                pr_err("kfd: queue id does not match any known queue\n");
 290                return -EINVAL;
 291        }
 292
 293        dev = NULL;
 294        if (pqn->kq)
 295                dev = pqn->kq->dev;
 296        if (pqn->q)
 297                dev = pqn->q->device;
 298        BUG_ON(!dev);
 299
 300        pdd = kfd_get_process_device_data(dev, pqm->process);
 301        if (!pdd) {
 302                pr_err("Process device data doesn't exist\n");
 303                return -1;
 304        }
 305
 306        if (pqn->kq) {
 307                /* destroy kernel queue (DIQ) */
 308                dqm = pqn->kq->dev->dqm;
 309                dqm->ops.destroy_kernel_queue(dqm, pqn->kq, &pdd->qpd);
 310                kernel_queue_uninit(pqn->kq);
 311        }
 312
 313        if (pqn->q) {
 314                dqm = pqn->q->device->dqm;
 315                retval = dqm->ops.destroy_queue(dqm, &pdd->qpd, pqn->q);
 316                if (retval != 0)
 317                        return retval;
 318
 319                uninit_queue(pqn->q);
 320        }
 321
 322        list_del(&pqn->process_queue_list);
 323        kfree(pqn);
 324        clear_bit(qid, pqm->queue_slot_bitmap);
 325
 326        if (list_empty(&pqm->queues))
 327                dqm->ops.unregister_process(dqm, &pdd->qpd);
 328
 329        return retval;
 330}
 331
 332int pqm_update_queue(struct process_queue_manager *pqm, unsigned int qid,
 333                        struct queue_properties *p)
 334{
 335        int retval;
 336        struct process_queue_node *pqn;
 337
 338        BUG_ON(!pqm);
 339
 340        pqn = get_queue_by_qid(pqm, qid);
 341        if (!pqn) {
 342                pr_debug("amdkfd: No queue %d exists for update operation\n",
 343                                qid);
 344                return -EFAULT;
 345        }
 346
 347        pqn->q->properties.queue_address = p->queue_address;
 348        pqn->q->properties.queue_size = p->queue_size;
 349        pqn->q->properties.queue_percent = p->queue_percent;
 350        pqn->q->properties.priority = p->priority;
 351
 352        retval = pqn->q->device->dqm->ops.update_queue(pqn->q->device->dqm,
 353                                                        pqn->q);
 354        if (retval != 0)
 355                return retval;
 356
 357        return 0;
 358}
 359
 360struct kernel_queue *pqm_get_kernel_queue(
 361                                        struct process_queue_manager *pqm,
 362                                        unsigned int qid)
 363{
 364        struct process_queue_node *pqn;
 365
 366        BUG_ON(!pqm);
 367
 368        pqn = get_queue_by_qid(pqm, qid);
 369        if (pqn && pqn->kq)
 370                return pqn->kq;
 371
 372        return NULL;
 373}
 374
 375
 376