Quelle  grukdump.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * SN Platform GRU Driver
 *
 *            Dump GRU State
 *
 *  Copyright (c) 2008 Silicon Graphics, Inc.  All Rights Reserved.
 */

#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/spinlock.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/bitops.h>
#include <asm/uv/uv_hub.h>

#include <linux/nospec.h>

#include "gru.h"
#include "grutables.h"
#include "gruhandles.h"
#include "grulib.h"

#define CCH_LOCK_ATTEMPTS 10

static int gru_user_copy_handle(void __user **dp, void *s)
{
 if (copy_to_user(*dp, s, GRU_HANDLE_BYTES))
  return -1;
 *dp += GRU_HANDLE_BYTES;
 return 0;
}

static int gru_dump_context_data(void *grubase,
   struct gru_context_configuration_handle *cch,
   void __user *ubuf, int ctxnum, int dsrcnt,
   int flush_cbrs)
{
 void *cb, *cbe, *tfh, *gseg;
 int i, scr;

 gseg = grubase + ctxnum * GRU_GSEG_STRIDE;
 cb = gseg + GRU_CB_BASE;
 cbe = grubase + GRU_CBE_BASE;
 tfh = grubase + GRU_TFH_BASE;

 for_each_cbr_in_allocation_map(i, &cch->cbr_allocation_map, scr) {
  if (flush_cbrs)
   gru_flush_cache(cb);
  if (gru_user_copy_handle(&ubuf, cb))
   goto fail;
  if (gru_user_copy_handle(&ubuf, tfh + i * GRU_HANDLE_STRIDE))
   goto fail;
  if (gru_user_copy_handle(&ubuf, cbe + i * GRU_HANDLE_STRIDE))
   goto fail;
  cb += GRU_HANDLE_STRIDE;
 }
 if (dsrcnt)
  memcpy(ubuf, gseg + GRU_DS_BASE, dsrcnt * GRU_HANDLE_STRIDE);
 return 0;

fail:
 return -EFAULT;
}

static int gru_dump_tfm(struct gru_state *gru,
  void __user *ubuf, void __user *ubufend)
{
 struct gru_tlb_fault_map *tfm;
 int i;

 if (GRU_NUM_TFM * GRU_CACHE_LINE_BYTES > ubufend - ubuf)
  return -EFBIG;

 for (i = 0; i < GRU_NUM_TFM; i++) {
  tfm = get_tfm(gru->gs_gru_base_vaddr, i);
  if (gru_user_copy_handle(&ubuf, tfm))
   goto fail;
 }
 return GRU_NUM_TFM * GRU_CACHE_LINE_BYTES;

fail:
 return -EFAULT;
}

static int gru_dump_tgh(struct gru_state *gru,
  void __user *ubuf, void __user *ubufend)
{
 struct gru_tlb_global_handle *tgh;
 int i;

 if (GRU_NUM_TGH * GRU_CACHE_LINE_BYTES > ubufend - ubuf)
  return -EFBIG;

 for (i = 0; i < GRU_NUM_TGH; i++) {
  tgh = get_tgh(gru->gs_gru_base_vaddr, i);
  if (gru_user_copy_handle(&ubuf, tgh))
   goto fail;
 }
 return GRU_NUM_TGH * GRU_CACHE_LINE_BYTES;

fail:
 return -EFAULT;
}

static int gru_dump_context(struct gru_state *gru, int ctxnum,
  void __user *ubuf, void __user *ubufend, char data_opt,
  char lock_cch, char flush_cbrs)
{
 struct gru_dump_context_header hdr;
 struct gru_dump_context_header __user *uhdr = ubuf;
 struct gru_context_configuration_handle *cch, *ubufcch;
 struct gru_thread_state *gts;
 int try, cch_locked, cbrcnt = 0, dsrcnt = 0, bytes = 0, ret = 0;
 void *grubase;

 memset(&hdr, 0, sizeof(hdr));
 grubase = gru->gs_gru_base_vaddr;
 cch = get_cch(grubase, ctxnum);
 for (try = 0; try < CCH_LOCK_ATTEMPTS; try++) {
  cch_locked =  trylock_cch_handle(cch);
  if (cch_locked)
   break;
  msleep(1);
 }

 ubuf += sizeof(hdr);
 ubufcch = ubuf;
 if (gru_user_copy_handle(&ubuf, cch)) {
  if (cch_locked)
   unlock_cch_handle(cch);
  return -EFAULT;
 }
 if (cch_locked)
  ubufcch->delresp = 0;
 bytes = sizeof(hdr) + GRU_CACHE_LINE_BYTES;

 if (cch_locked || !lock_cch) {
  gts = gru->gs_gts[ctxnum];
  if (gts && gts->ts_vma) {
   hdr.pid = gts->ts_tgid_owner;
   hdr.vaddr = gts->ts_vma->vm_start;
  }
  if (cch->state != CCHSTATE_INACTIVE) {
   cbrcnt = hweight64(cch->cbr_allocation_map) *
      GRU_CBR_AU_SIZE;
   dsrcnt = data_opt ? hweight32(cch->dsr_allocation_map) *
      GRU_DSR_AU_CL : 0;
  }
  bytes += (3 * cbrcnt + dsrcnt) * GRU_CACHE_LINE_BYTES;
  if (bytes > ubufend - ubuf)
   ret = -EFBIG;
  else
   ret = gru_dump_context_data(grubase, cch, ubuf, ctxnum,
       dsrcnt, flush_cbrs);
 }
 if (cch_locked)
  unlock_cch_handle(cch);
 if (ret)
  return ret;

 hdr.magic = GRU_DUMP_MAGIC;
 hdr.gid = gru->gs_gid;
 hdr.ctxnum = ctxnum;
 hdr.cbrcnt = cbrcnt;
 hdr.dsrcnt = dsrcnt;
 hdr.cch_locked = cch_locked;
 if (copy_to_user(uhdr, &hdr, sizeof(hdr)))
  return -EFAULT;

 return bytes;
}

int gru_dump_chiplet_request(unsigned long arg)
{
 struct gru_state *gru;
 struct gru_dump_chiplet_state_req req;
 void __user *ubuf;
 void __user *ubufend;
 int ctxnum, ret, cnt = 0;

 if (copy_from_user(&req, (void __user *)arg, sizeof(req)))
  return -EFAULT;

 /* Currently, only dump by gid is implemented */
 if (req.gid >= gru_max_gids)
  return -EINVAL;
 req.gid = array_index_nospec(req.gid, gru_max_gids);

 gru = GID_TO_GRU(req.gid);
 ubuf = req.buf;
 ubufend = req.buf + req.buflen;

 ret = gru_dump_tfm(gru, ubuf, ubufend);
 if (ret < 0)
  goto fail;
 ubuf += ret;

 ret = gru_dump_tgh(gru, ubuf, ubufend);
 if (ret < 0)
  goto fail;
 ubuf += ret;

 for (ctxnum = 0; ctxnum < GRU_NUM_CCH; ctxnum++) {
  if (req.ctxnum == ctxnum || req.ctxnum < 0) {
   ret = gru_dump_context(gru, ctxnum, ubuf, ubufend,
      req.data_opt, req.lock_cch,
      req.flush_cbrs);
   if (ret < 0)
    goto fail;
   ubuf += ret;
   cnt++;
  }
 }

 if (copy_to_user((void __user *)arg, &req, sizeof(req)))
  return -EFAULT;
 return cnt;

fail:
 return ret;
}