drivers/gpu/drm/msm/msm_rd.c

   1 /*
   2  * Copyright (C) 2013 Red Hat
   3  * Author: Rob Clark <robdclark@gmail.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 /* For debugging crashes, userspace can:
  19  *
  20  *   tail -f /sys/kernel/debug/dri/<minor>/rd > logfile.rd
  21  *
  22  * To log the cmdstream in a format that is understood by freedreno/cffdump
  23  * utility.  By comparing the last successfully completed fence #, to the
  24  * cmdstream for the next fence, you can narrow down which process and submit
  25  * caused the gpu crash/lockup.
  26  *
  27  * This bypasses drm_debugfs_create_files() mainly because we need to use
  28  * our own fops for a bit more control.  In particular, we don't want to
  29  * do anything if userspace doesn't have the debugfs file open.
  30  */
  31
  32 #ifdef CONFIG_DEBUG_FS
  33
  34 #include <linux/kfifo.h>
  35 #include <linux/debugfs.h>
  36 #include <linux/circ_buf.h>
  37 #include <linux/wait.h>
  38
  39 #include "msm_drv.h"
  40 #include "msm_gpu.h"
  41 #include "msm_gem.h"
  42
  43 enum rd_sect_type {
  44         RD_NONE,
  45         RD_TEST,       /* ascii text */
  46         RD_CMD,        /* ascii text */
  47         RD_GPUADDR,    /* u32 gpuaddr, u32 size */
  48         RD_CONTEXT,    /* raw dump */
  49         RD_CMDSTREAM,  /* raw dump */
  50         RD_CMDSTREAM_ADDR, /* gpu addr of cmdstream */
  51         RD_PARAM,      /* u32 param_type, u32 param_val, u32 bitlen */
  52         RD_FLUSH,      /* empty, clear previous params */
  53         RD_PROGRAM,    /* shader program, raw dump */
  54         RD_VERT_SHADER,
  55         RD_FRAG_SHADER,
  56         RD_BUFFER_CONTENTS,
  57         RD_GPU_ID,
  58 };
  59
  60 #define BUF_SZ 512  /* should be power of 2 */
  61
  62 /* space used: */
  63 #define circ_count(circ) \
  64         (CIRC_CNT((circ)->head, (circ)->tail, BUF_SZ))
  65 #define circ_count_to_end(circ) \
  66         (CIRC_CNT_TO_END((circ)->head, (circ)->tail, BUF_SZ))
  67 /* space available: */
  68 #define circ_space(circ) \
  69         (CIRC_SPACE((circ)->head, (circ)->tail, BUF_SZ))
  70 #define circ_space_to_end(circ) \
  71         (CIRC_SPACE_TO_END((circ)->head, (circ)->tail, BUF_SZ))
  72
  73 struct msm_rd_state {
  74         struct drm_device *dev;
  75
  76         bool open;
  77
  78         struct dentry *ent;
  79         struct drm_info_node *node;
  80
  81         /* current submit to read out: */
  82         struct msm_gem_submit *submit;
  83
  84         /* fifo access is synchronized on the producer side by
  85          * struct_mutex held by submit code (otherwise we could
  86          * end up w/ cmds logged in different order than they
  87          * were executed).  And read_lock synchronizes the reads
  88          */
  89         struct mutex read_lock;
  90
  91         wait_queue_head_t fifo_event;
  92         struct circ_buf fifo;
  93
  94         char buf[BUF_SZ];
  95 };
  96
  97 static void rd_write(struct msm_rd_state *rd, const void *buf, int sz)
  98 {
  99         struct circ_buf *fifo = &rd->fifo;
 100         const char *ptr = buf;
 101
 102         while (sz > 0) {
 103                 char *fptr = &fifo->buf[fifo->head];
 104                 int n;
 105
 106                 wait_event(rd->fifo_event, circ_space(&rd->fifo) > 0 || !rd->open);
 107                 if (!rd->open)
 108                         return;
 109
 110                 n = min(sz, circ_space_to_end(&rd->fifo));
 111                 memcpy(fptr, ptr, n);
 112
 113                 fifo->head = (fifo->head + n) & (BUF_SZ - 1);
 114                 sz  -= n;
 115                 ptr += n;
 116
 117                 wake_up_all(&rd->fifo_event);
 118         }
 119 }
 120
 121 static void rd_write_section(struct msm_rd_state *rd,
 122                 enum rd_sect_type type, const void *buf, int sz)
 123 {
 124         rd_write(rd, &type, 4);
 125         rd_write(rd, &sz, 4);
 126         rd_write(rd, buf, sz);
 127 }
 128
 129 static ssize_t rd_read(struct file *file, char __user *buf,
 130                 size_t sz, loff_t *ppos)
 131 {
 132         struct msm_rd_state *rd = file->private_data;
 133         struct circ_buf *fifo = &rd->fifo;
 134         const char *fptr = &fifo->buf[fifo->tail];
 135         int n = 0, ret = 0;
 136
 137         mutex_lock(&rd->read_lock);
 138
 139         ret = wait_event_interruptible(rd->fifo_event,
 140                         circ_count(&rd->fifo) > 0);
 141         if (ret)
 142                 goto out;
 143
 144         n = min_t(int, sz, circ_count_to_end(&rd->fifo));
 145         ret = copy_to_user(buf, fptr, n);
 146         if (ret)
 147                 goto out;
 148
 149         fifo->tail = (fifo->tail + n) & (BUF_SZ - 1);
 150         *ppos += n;
 151
 152         wake_up_all(&rd->fifo_event);
 153
 154 out:
 155         mutex_unlock(&rd->read_lock);
 156         if (ret)
 157                 return ret;
 158         return n;
 159 }
 160
 161 static int rd_open(struct inode *inode, struct file *file)
 162 {
 163         struct msm_rd_state *rd = inode->i_private;
 164         struct drm_device *dev = rd->dev;
 165         struct msm_drm_private *priv = dev->dev_private;
 166         struct msm_gpu *gpu = priv->gpu;
 167         uint64_t val;
 168         uint32_t gpu_id;
 169         int ret = 0;
 170
 171         mutex_lock(&dev->struct_mutex);
 172
 173         if (rd->open || !gpu) {
 174                 ret = -EBUSY;
 175                 goto out;
 176         }
 177
 178         file->private_data = rd;
 179         rd->open = true;
 180
 181         /* the parsing tools need to know gpu-id to know which
 182          * register database to load.
 183          */
 184         gpu->funcs->get_param(gpu, MSM_PARAM_GPU_ID, &val);
 185         gpu_id = val;
 186
 187         rd_write_section(rd, RD_GPU_ID, &gpu_id, sizeof(gpu_id));
 188
 189 out:
 190         mutex_unlock(&dev->struct_mutex);
 191         return ret;
 192 }
 193
 194 static int rd_release(struct inode *inode, struct file *file)
 195 {
 196         struct msm_rd_state *rd = inode->i_private;
 197
 198         rd->open = false;
 199         wake_up_all(&rd->fifo_event);
 200
 201         return 0;
 202 }
 203
 204
 205 static const struct file_operations rd_debugfs_fops = {
 206         .owner = THIS_MODULE,
 207         .open = rd_open,
 208         .read = rd_read,
 209         .llseek = no_llseek,
 210         .release = rd_release,
 211 };
 212
 213 int msm_rd_debugfs_init(struct drm_minor *minor)
 214 {
 215         struct msm_drm_private *priv = minor->dev->dev_private;
 216         struct msm_rd_state *rd;
 217
 218         /* only create on first minor: */
 219         if (priv->rd)
 220                 return 0;
 221
 222         rd = kzalloc(sizeof(*rd), GFP_KERNEL);
 223         if (!rd)
 224                 return -ENOMEM;
 225
 226         rd->dev = minor->dev;
 227         rd->fifo.buf = rd->buf;
 228
 229         mutex_init(&rd->read_lock);
 230         priv->rd = rd;
 231
 232         init_waitqueue_head(&rd->fifo_event);
 233
 234         rd->node = kzalloc(sizeof(*rd->node), GFP_KERNEL);
 235         if (!rd->node)
 236                 goto fail;
 237
 238         rd->ent = debugfs_create_file("rd", S_IFREG | S_IRUGO,
 239                         minor->debugfs_root, rd, &rd_debugfs_fops);
 240         if (!rd->ent) {
 241                 DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s/rd\n",
 242                                 minor->debugfs_root->d_name.name);
 243                 goto fail;
 244         }
 245
 246         rd->node->minor = minor;
 247         rd->node->dent  = rd->ent;
 248         rd->node->info_ent = NULL;
 249
 250         mutex_lock(&minor->debugfs_lock);
 251         list_add(&rd->node->list, &minor->debugfs_list);
 252         mutex_unlock(&minor->debugfs_lock);
 253
 254         return 0;
 255
 256 fail:
 257         msm_rd_debugfs_cleanup(minor);
 258         return -1;
 259 }
 260
 261 void msm_rd_debugfs_cleanup(struct drm_minor *minor)
 262 {
 263         struct msm_drm_private *priv = minor->dev->dev_private;
 264         struct msm_rd_state *rd = priv->rd;
 265
 266         if (!rd)
 267                 return;
 268
 269         priv->rd = NULL;
 270
 271         debugfs_remove(rd->ent);
 272
 273         if (rd->node) {
 274                 mutex_lock(&minor->debugfs_lock);
 275                 list_del(&rd->node->list);
 276                 mutex_unlock(&minor->debugfs_lock);
 277                 kfree(rd->node);
 278         }
 279
 280         mutex_destroy(&rd->read_lock);
 281
 282         kfree(rd);
 283 }
 284
 285 /* called under struct_mutex */
 286 void msm_rd_dump_submit(struct msm_gem_submit *submit)
 287 {
 288         struct drm_device *dev = submit->dev;
 289         struct msm_drm_private *priv = dev->dev_private;
 290         struct msm_rd_state *rd = priv->rd;
 291         char msg[128];
 292         int i, n;
 293
 294         if (!rd->open)
 295                 return;
 296
 297         /* writing into fifo is serialized by caller, and
 298          * rd->read_lock is used to serialize the reads
 299          */
 300         WARN_ON(!mutex_is_locked(&dev->struct_mutex));
 301
 302         n = snprintf(msg, sizeof(msg), "%.*s/%d: fence=%u",
 303                         TASK_COMM_LEN, current->comm, task_pid_nr(current),
 304                         submit->fence);
 305
 306         rd_write_section(rd, RD_CMD, msg, ALIGN(n, 4));
 307
 308         /* could be nice to have an option (module-param?) to snapshot
 309          * all the bo's associated with the submit.  Handy to see vtx
 310          * buffers, etc.  For now just the cmdstream bo's is enough.
 311          */
 312
 313         for (i = 0; i < submit->nr_cmds; i++) {
 314                 uint32_t idx  = submit->cmd[i].idx;
 315                 uint32_t iova = submit->cmd[i].iova;
 316                 uint32_t szd  = submit->cmd[i].size; /* in dwords */
 317                 struct msm_gem_object *obj = submit->bos[idx].obj;
 318                 const char *buf = msm_gem_vaddr_locked(&obj->base);
 319
 320                 buf += iova - submit->bos[idx].iova;
 321
 322                 rd_write_section(rd, RD_GPUADDR,
 323                                 (uint32_t[2]){ iova, szd * 4 }, 8);
 324                 rd_write_section(rd, RD_BUFFER_CONTENTS,
 325                                 buf, szd * 4);
 326
 327                 switch (submit->cmd[i].type) {
 328                 case MSM_SUBMIT_CMD_IB_TARGET_BUF:
 329                         /* ignore IB-targets, we've logged the buffer, the
 330                          * parser tool will follow the IB based on the logged
 331                          * buffer/gpuaddr, so nothing more to do.
 332                          */
 333                         break;
 334                 case MSM_SUBMIT_CMD_CTX_RESTORE_BUF:
 335                 case MSM_SUBMIT_CMD_BUF:
 336                         rd_write_section(rd, RD_CMDSTREAM_ADDR,
 337                                         (uint32_t[2]){ iova, szd }, 8);
 338                         break;
 339                 }
 340         }
 341 }
 342 #endif