drivers/net/ethernet/mellanox/mlx5/core/diag/fw_tracer.c

   1 /*
   2  * Copyright (c) 2018, Mellanox Technologies. All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32 #define CREATE_TRACE_POINTS
  33 #include "lib/eq.h"
  34 #include "fw_tracer.h"
  35 #include "fw_tracer_tracepoint.h"
  36
  37 static int mlx5_query_mtrc_caps(struct mlx5_fw_tracer *tracer)
  38 {
  39         u32 *string_db_base_address_out = tracer->str_db.base_address_out;
  40         u32 *string_db_size_out = tracer->str_db.size_out;
  41         struct mlx5_core_dev *dev = tracer->dev;
  42         u32 out[MLX5_ST_SZ_DW(mtrc_cap)] = {0};
  43         u32 in[MLX5_ST_SZ_DW(mtrc_cap)] = {0};
  44         void *mtrc_cap_sp;
  45         int err, i;
  46
  47         err = mlx5_core_access_reg(dev, in, sizeof(in), out, sizeof(out),
  48                                    MLX5_REG_MTRC_CAP, 0, 0);
  49         if (err) {
  50                 mlx5_core_warn(dev, "FWTracer: Error reading tracer caps %d\n",
  51                                err);
  52                 return err;
  53         }
  54
  55         if (!MLX5_GET(mtrc_cap, out, trace_to_memory)) {
  56                 mlx5_core_dbg(dev, "FWTracer: Device does not support logging traces to memory\n");
  57                 return -ENOTSUPP;
  58         }
  59
  60         tracer->trc_ver = MLX5_GET(mtrc_cap, out, trc_ver);
  61         tracer->str_db.first_string_trace =
  62                         MLX5_GET(mtrc_cap, out, first_string_trace);
  63         tracer->str_db.num_string_trace =
  64                         MLX5_GET(mtrc_cap, out, num_string_trace);
  65         tracer->str_db.num_string_db = MLX5_GET(mtrc_cap, out, num_string_db);
  66         tracer->owner = !!MLX5_GET(mtrc_cap, out, trace_owner);
  67         tracer->str_db.loaded = false;
  68
  69         for (i = 0; i < tracer->str_db.num_string_db; i++) {
  70                 mtrc_cap_sp = MLX5_ADDR_OF(mtrc_cap, out, string_db_param[i]);
  71                 string_db_base_address_out[i] = MLX5_GET(mtrc_string_db_param,
  72                                                          mtrc_cap_sp,
  73                                                          string_db_base_address);
  74                 string_db_size_out[i] = MLX5_GET(mtrc_string_db_param,
  75                                                  mtrc_cap_sp, string_db_size);
  76         }
  77
  78         return err;
  79 }
  80
  81 static int mlx5_set_mtrc_caps_trace_owner(struct mlx5_fw_tracer *tracer,
  82                                           u32 *out, u32 out_size,
  83                                           u8 trace_owner)
  84 {
  85         struct mlx5_core_dev *dev = tracer->dev;
  86         u32 in[MLX5_ST_SZ_DW(mtrc_cap)] = {0};
  87
  88         MLX5_SET(mtrc_cap, in, trace_owner, trace_owner);
  89
  90         return mlx5_core_access_reg(dev, in, sizeof(in), out, out_size,
  91                                     MLX5_REG_MTRC_CAP, 0, 1);
  92 }
  93
  94 static int mlx5_fw_tracer_ownership_acquire(struct mlx5_fw_tracer *tracer)
  95 {
  96         struct mlx5_core_dev *dev = tracer->dev;
  97         u32 out[MLX5_ST_SZ_DW(mtrc_cap)] = {0};
  98         int err;
  99
 100         err = mlx5_set_mtrc_caps_trace_owner(tracer, out, sizeof(out),
 101                                              MLX5_FW_TRACER_ACQUIRE_OWNERSHIP);
 102         if (err) {
 103                 mlx5_core_warn(dev, "FWTracer: Acquire tracer ownership failed %d\n",
 104                                err);
 105                 return err;
 106         }
 107
 108         tracer->owner = !!MLX5_GET(mtrc_cap, out, trace_owner);
 109
 110         if (!tracer->owner)
 111                 return -EBUSY;
 112
 113         return 0;
 114 }
 115
 116 static void mlx5_fw_tracer_ownership_release(struct mlx5_fw_tracer *tracer)
 117 {
 118         u32 out[MLX5_ST_SZ_DW(mtrc_cap)] = {0};
 119
 120         mlx5_set_mtrc_caps_trace_owner(tracer, out, sizeof(out),
 121                                        MLX5_FW_TRACER_RELEASE_OWNERSHIP);
 122         tracer->owner = false;
 123 }
 124
 125 static int mlx5_fw_tracer_create_log_buf(struct mlx5_fw_tracer *tracer)
 126 {
 127         struct mlx5_core_dev *dev = tracer->dev;
 128         struct device *ddev;
 129         dma_addr_t dma;
 130         void *buff;
 131         gfp_t gfp;
 132         int err;
 133
 134         tracer->buff.size = TRACE_BUFFER_SIZE_BYTE;
 135
 136         gfp = GFP_KERNEL | __GFP_ZERO;
 137         buff = (void *)__get_free_pages(gfp,
 138                                         get_order(tracer->buff.size));
 139         if (!buff) {
 140                 err = -ENOMEM;
 141                 mlx5_core_warn(dev, "FWTracer: Failed to allocate pages, %d\n", err);
 142                 return err;
 143         }
 144         tracer->buff.log_buf = buff;
 145
 146         ddev = mlx5_core_dma_dev(dev);
 147         dma = dma_map_single(ddev, buff, tracer->buff.size, DMA_FROM_DEVICE);
 148         if (dma_mapping_error(ddev, dma)) {
 149                 mlx5_core_warn(dev, "FWTracer: Unable to map DMA: %d\n",
 150                                dma_mapping_error(ddev, dma));
 151                 err = -ENOMEM;
 152                 goto free_pages;
 153         }
 154         tracer->buff.dma = dma;
 155
 156         return 0;
 157
 158 free_pages:
 159         free_pages((unsigned long)tracer->buff.log_buf, get_order(tracer->buff.size));
 160
 161         return err;
 162 }
 163
 164 static void mlx5_fw_tracer_destroy_log_buf(struct mlx5_fw_tracer *tracer)
 165 {
 166         struct mlx5_core_dev *dev = tracer->dev;
 167         struct device *ddev;
 168
 169         if (!tracer->buff.log_buf)
 170                 return;
 171
 172         ddev = mlx5_core_dma_dev(dev);
 173         dma_unmap_single(ddev, tracer->buff.dma, tracer->buff.size, DMA_FROM_DEVICE);
 174         free_pages((unsigned long)tracer->buff.log_buf, get_order(tracer->buff.size));
 175 }
 176
 177 static int mlx5_fw_tracer_create_mkey(struct mlx5_fw_tracer *tracer)
 178 {
 179         struct mlx5_core_dev *dev = tracer->dev;
 180         int err, inlen, i;
 181         __be64 *mtt;
 182         void *mkc;
 183         u32 *in;
 184
 185         inlen = MLX5_ST_SZ_BYTES(create_mkey_in) +
 186                         sizeof(*mtt) * round_up(TRACER_BUFFER_PAGE_NUM, 2);
 187
 188         in = kvzalloc(inlen, GFP_KERNEL);
 189         if (!in)
 190                 return -ENOMEM;
 191
 192         MLX5_SET(create_mkey_in, in, translations_octword_actual_size,
 193                  DIV_ROUND_UP(TRACER_BUFFER_PAGE_NUM, 2));
 194         mtt = (__be64 *)MLX5_ADDR_OF(create_mkey_in, in, klm_pas_mtt);
 195         for (i = 0 ; i < TRACER_BUFFER_PAGE_NUM ; i++)
 196                 mtt[i] = cpu_to_be64(tracer->buff.dma + i * PAGE_SIZE);
 197
 198         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
 199         MLX5_SET(mkc, mkc, access_mode_1_0, MLX5_MKC_ACCESS_MODE_MTT);
 200         MLX5_SET(mkc, mkc, lr, 1);
 201         MLX5_SET(mkc, mkc, lw, 1);
 202         MLX5_SET(mkc, mkc, pd, tracer->buff.pdn);
 203         MLX5_SET(mkc, mkc, bsf_octword_size, 0);
 204         MLX5_SET(mkc, mkc, qpn, 0xffffff);
 205         MLX5_SET(mkc, mkc, log_page_size, PAGE_SHIFT);
 206         MLX5_SET(mkc, mkc, translations_octword_size,
 207                  DIV_ROUND_UP(TRACER_BUFFER_PAGE_NUM, 2));
 208         MLX5_SET64(mkc, mkc, start_addr, tracer->buff.dma);
 209         MLX5_SET64(mkc, mkc, len, tracer->buff.size);
 210         err = mlx5_core_create_mkey(dev, &tracer->buff.mkey, in, inlen);
 211         if (err)
 212                 mlx5_core_warn(dev, "FWTracer: Failed to create mkey, %d\n", err);
 213
 214         kvfree(in);
 215
 216         return err;
 217 }
 218
 219 static void mlx5_fw_tracer_free_strings_db(struct mlx5_fw_tracer *tracer)
 220 {
 221         u32 num_string_db = tracer->str_db.num_string_db;
 222         int i;
 223
 224         for (i = 0; i < num_string_db; i++) {
 225                 kfree(tracer->str_db.buffer[i]);
 226                 tracer->str_db.buffer[i] = NULL;
 227         }
 228 }
 229
 230 static int mlx5_fw_tracer_allocate_strings_db(struct mlx5_fw_tracer *tracer)
 231 {
 232         u32 *string_db_size_out = tracer->str_db.size_out;
 233         u32 num_string_db = tracer->str_db.num_string_db;
 234         int i;
 235
 236         for (i = 0; i < num_string_db; i++) {
 237                 if (!string_db_size_out[i])
 238                         continue;
 239                 tracer->str_db.buffer[i] = kzalloc(string_db_size_out[i], GFP_KERNEL);
 240                 if (!tracer->str_db.buffer[i])
 241                         goto free_strings_db;
 242         }
 243
 244         return 0;
 245
 246 free_strings_db:
 247         mlx5_fw_tracer_free_strings_db(tracer);
 248         return -ENOMEM;
 249 }
 250
 251 static void
 252 mlx5_fw_tracer_init_saved_traces_array(struct mlx5_fw_tracer *tracer)
 253 {
 254         tracer->st_arr.saved_traces_index = 0;
 255         mutex_init(&tracer->st_arr.lock);
 256 }
 257
 258 static void
 259 mlx5_fw_tracer_clean_saved_traces_array(struct mlx5_fw_tracer *tracer)
 260 {
 261         mutex_destroy(&tracer->st_arr.lock);
 262 }
 263
 264 static void mlx5_tracer_read_strings_db(struct work_struct *work)
 265 {
 266         struct mlx5_fw_tracer *tracer = container_of(work, struct mlx5_fw_tracer,
 267                                                      read_fw_strings_work);
 268         u32 num_of_reads, num_string_db = tracer->str_db.num_string_db;
 269         struct mlx5_core_dev *dev = tracer->dev;
 270         u32 in[MLX5_ST_SZ_DW(mtrc_cap)] = {0};
 271         u32 leftovers, offset;
 272         int err = 0, i, j;
 273         u32 *out, outlen;
 274         void *out_value;
 275
 276         outlen = MLX5_ST_SZ_BYTES(mtrc_stdb) + STRINGS_DB_READ_SIZE_BYTES;
 277         out = kzalloc(outlen, GFP_KERNEL);
 278         if (!out) {
 279                 err = -ENOMEM;
 280                 goto out;
 281         }
 282
 283         for (i = 0; i < num_string_db; i++) {
 284                 if (!tracer->str_db.size_out[i])
 285                         continue;
 286                 offset = 0;
 287                 MLX5_SET(mtrc_stdb, in, string_db_index, i);
 288                 num_of_reads = tracer->str_db.size_out[i] /
 289                                 STRINGS_DB_READ_SIZE_BYTES;
 290                 leftovers = (tracer->str_db.size_out[i] %
 291                                 STRINGS_DB_READ_SIZE_BYTES) /
 292                                         STRINGS_DB_LEFTOVER_SIZE_BYTES;
 293
 294                 MLX5_SET(mtrc_stdb, in, read_size, STRINGS_DB_READ_SIZE_BYTES);
 295                 for (j = 0; j < num_of_reads; j++) {
 296                         MLX5_SET(mtrc_stdb, in, start_offset, offset);
 297
 298                         err = mlx5_core_access_reg(dev, in, sizeof(in), out,
 299                                                    outlen, MLX5_REG_MTRC_STDB,
 300                                                    0, 1);
 301                         if (err) {
 302                                 mlx5_core_dbg(dev, "FWTracer: Failed to read strings DB %d\n",
 303                                               err);
 304                                 goto out_free;
 305                         }
 306
 307                         out_value = MLX5_ADDR_OF(mtrc_stdb, out, string_db_data);
 308                         memcpy(tracer->str_db.buffer[i] + offset, out_value,
 309                                STRINGS_DB_READ_SIZE_BYTES);
 310                         offset += STRINGS_DB_READ_SIZE_BYTES;
 311                 }
 312
 313                 /* Strings database is aligned to 64, need to read leftovers*/
 314                 MLX5_SET(mtrc_stdb, in, read_size,
 315                          STRINGS_DB_LEFTOVER_SIZE_BYTES);
 316                 for (j = 0; j < leftovers; j++) {
 317                         MLX5_SET(mtrc_stdb, in, start_offset, offset);
 318
 319                         err = mlx5_core_access_reg(dev, in, sizeof(in), out,
 320                                                    outlen, MLX5_REG_MTRC_STDB,
 321                                                    0, 1);
 322                         if (err) {
 323                                 mlx5_core_dbg(dev, "FWTracer: Failed to read strings DB %d\n",
 324                                               err);
 325                                 goto out_free;
 326                         }
 327
 328                         out_value = MLX5_ADDR_OF(mtrc_stdb, out, string_db_data);
 329                         memcpy(tracer->str_db.buffer[i] + offset, out_value,
 330                                STRINGS_DB_LEFTOVER_SIZE_BYTES);
 331                         offset += STRINGS_DB_LEFTOVER_SIZE_BYTES;
 332                 }
 333         }
 334
 335         tracer->str_db.loaded = true;
 336
 337 out_free:
 338         kfree(out);
 339 out:
 340         return;
 341 }
 342
 343 static void mlx5_fw_tracer_arm(struct mlx5_core_dev *dev)
 344 {
 345         u32 out[MLX5_ST_SZ_DW(mtrc_ctrl)] = {0};
 346         u32 in[MLX5_ST_SZ_DW(mtrc_ctrl)] = {0};
 347         int err;
 348
 349         MLX5_SET(mtrc_ctrl, in, arm_event, 1);
 350
 351         err = mlx5_core_access_reg(dev, in, sizeof(in), out, sizeof(out),
 352                                    MLX5_REG_MTRC_CTRL, 0, 1);
 353         if (err)
 354                 mlx5_core_warn(dev, "FWTracer: Failed to arm tracer event %d\n", err);
 355 }
 356
 357 static const char *VAL_PARM             = "%llx";
 358 static const char *REPLACE_64_VAL_PARM  = "%x%x";
 359 static const char *PARAM_CHAR           = "%";
 360
 361 static int mlx5_tracer_message_hash(u32 message_id)
 362 {
 363         return jhash_1word(message_id, 0) & (MESSAGE_HASH_SIZE - 1);
 364 }
 365
 366 static struct tracer_string_format *mlx5_tracer_message_insert(struct mlx5_fw_tracer *tracer,
 367                                                                struct tracer_event *tracer_event)
 368 {
 369         struct hlist_head *head =
 370                 &tracer->hash[mlx5_tracer_message_hash(tracer_event->string_event.tmsn)];
 371         struct tracer_string_format *cur_string;
 372
 373         cur_string = kzalloc(sizeof(*cur_string), GFP_KERNEL);
 374         if (!cur_string)
 375                 return NULL;
 376
 377         hlist_add_head(&cur_string->hlist, head);
 378
 379         return cur_string;
 380 }
 381
 382 static struct tracer_string_format *mlx5_tracer_get_string(struct mlx5_fw_tracer *tracer,
 383                                                            struct tracer_event *tracer_event)
 384 {
 385         struct tracer_string_format *cur_string;
 386         u32 str_ptr, offset;
 387         int i;
 388
 389         str_ptr = tracer_event->string_event.string_param;
 390
 391         for (i = 0; i < tracer->str_db.num_string_db; i++) {
 392                 if (!tracer->str_db.size_out[i])
 393                         continue;
 394                 if (str_ptr > tracer->str_db.base_address_out[i] &&
 395                     str_ptr < tracer->str_db.base_address_out[i] +
 396                     tracer->str_db.size_out[i]) {
 397                         offset = str_ptr - tracer->str_db.base_address_out[i];
 398                         /* add it to the hash */
 399                         cur_string = mlx5_tracer_message_insert(tracer, tracer_event);
 400                         if (!cur_string)
 401                                 return NULL;
 402                         cur_string->string = (char *)(tracer->str_db.buffer[i] +
 403                                                         offset);
 404                         return cur_string;
 405                 }
 406         }
 407
 408         return NULL;
 409 }
 410
 411 static void mlx5_tracer_clean_message(struct tracer_string_format *str_frmt)
 412 {
 413         hlist_del(&str_frmt->hlist);
 414         kfree(str_frmt);
 415 }
 416
 417 static int mlx5_tracer_get_num_of_params(char *str)
 418 {
 419         char *substr, *pstr = str;
 420         int num_of_params = 0;
 421
 422         /* replace %llx with %x%x */
 423         substr = strstr(pstr, VAL_PARM);
 424         while (substr) {
 425                 memcpy(substr, REPLACE_64_VAL_PARM, 4);
 426                 pstr = substr;
 427                 substr = strstr(pstr, VAL_PARM);
 428         }
 429
 430         /* count all the % characters */
 431         substr = strstr(str, PARAM_CHAR);
 432         while (substr) {
 433                 num_of_params += 1;
 434                 str = substr + 1;
 435                 substr = strstr(str, PARAM_CHAR);
 436         }
 437
 438         return num_of_params;
 439 }
 440
 441 static struct tracer_string_format *mlx5_tracer_message_find(struct hlist_head *head,
 442                                                              u8 event_id, u32 tmsn)
 443 {
 444         struct tracer_string_format *message;
 445
 446         hlist_for_each_entry(message, head, hlist)
 447                 if (message->event_id == event_id && message->tmsn == tmsn)
 448                         return message;
 449
 450         return NULL;
 451 }
 452
 453 static struct tracer_string_format *mlx5_tracer_message_get(struct mlx5_fw_tracer *tracer,
 454                                                             struct tracer_event *tracer_event)
 455 {
 456         struct hlist_head *head =
 457                 &tracer->hash[mlx5_tracer_message_hash(tracer_event->string_event.tmsn)];
 458
 459         return mlx5_tracer_message_find(head, tracer_event->event_id, tracer_event->string_event.tmsn);
 460 }
 461
 462 static void poll_trace(struct mlx5_fw_tracer *tracer,
 463                        struct tracer_event *tracer_event, u64 *trace)
 464 {
 465         u32 timestamp_low, timestamp_mid, timestamp_high, urts;
 466
 467         tracer_event->event_id = MLX5_GET(tracer_event, trace, event_id);
 468         tracer_event->lost_event = MLX5_GET(tracer_event, trace, lost);
 469         tracer_event->out = trace;
 470
 471         switch (tracer_event->event_id) {
 472         case TRACER_EVENT_TYPE_TIMESTAMP:
 473                 tracer_event->type = TRACER_EVENT_TYPE_TIMESTAMP;
 474                 urts = MLX5_GET(tracer_timestamp_event, trace, urts);
 475                 if (tracer->trc_ver == 0)
 476                         tracer_event->timestamp_event.unreliable = !!(urts >> 2);
 477                 else
 478                         tracer_event->timestamp_event.unreliable = !!(urts & 1);
 479
 480                 timestamp_low = MLX5_GET(tracer_timestamp_event,
 481                                          trace, timestamp7_0);
 482                 timestamp_mid = MLX5_GET(tracer_timestamp_event,
 483                                          trace, timestamp39_8);
 484                 timestamp_high = MLX5_GET(tracer_timestamp_event,
 485                                           trace, timestamp52_40);
 486
 487                 tracer_event->timestamp_event.timestamp =
 488                                 ((u64)timestamp_high << 40) |
 489                                 ((u64)timestamp_mid << 8) |
 490                                 (u64)timestamp_low;
 491                 break;
 492         default:
 493                 if (tracer_event->event_id >= tracer->str_db.first_string_trace &&
 494                     tracer_event->event_id <= tracer->str_db.first_string_trace +
 495                                               tracer->str_db.num_string_trace) {
 496                         tracer_event->type = TRACER_EVENT_TYPE_STRING;
 497                         tracer_event->string_event.timestamp =
 498                                 MLX5_GET(tracer_string_event, trace, timestamp);
 499                         tracer_event->string_event.string_param =
 500                                 MLX5_GET(tracer_string_event, trace, string_param);
 501                         tracer_event->string_event.tmsn =
 502                                 MLX5_GET(tracer_string_event, trace, tmsn);
 503                         tracer_event->string_event.tdsn =
 504                                 MLX5_GET(tracer_string_event, trace, tdsn);
 505                 } else {
 506                         tracer_event->type = TRACER_EVENT_TYPE_UNRECOGNIZED;
 507                 }
 508                 break;
 509         }
 510 }
 511
 512 static u64 get_block_timestamp(struct mlx5_fw_tracer *tracer, u64 *ts_event)
 513 {
 514         struct tracer_event tracer_event;
 515         u8 event_id;
 516
 517         event_id = MLX5_GET(tracer_event, ts_event, event_id);
 518
 519         if (event_id == TRACER_EVENT_TYPE_TIMESTAMP)
 520                 poll_trace(tracer, &tracer_event, ts_event);
 521         else
 522                 tracer_event.timestamp_event.timestamp = 0;
 523
 524         return tracer_event.timestamp_event.timestamp;
 525 }
 526
 527 static void mlx5_fw_tracer_clean_print_hash(struct mlx5_fw_tracer *tracer)
 528 {
 529         struct tracer_string_format *str_frmt;
 530         struct hlist_node *n;
 531         int i;
 532
 533         for (i = 0; i < MESSAGE_HASH_SIZE; i++) {
 534                 hlist_for_each_entry_safe(str_frmt, n, &tracer->hash[i], hlist)
 535                         mlx5_tracer_clean_message(str_frmt);
 536         }
 537 }
 538
 539 static void mlx5_fw_tracer_clean_ready_list(struct mlx5_fw_tracer *tracer)
 540 {
 541         struct tracer_string_format *str_frmt, *tmp_str;
 542
 543         list_for_each_entry_safe(str_frmt, tmp_str, &tracer->ready_strings_list,
 544                                  list)
 545                 list_del(&str_frmt->list);
 546 }
 547
 548 static void mlx5_fw_tracer_save_trace(struct mlx5_fw_tracer *tracer,
 549                                       u64 timestamp, bool lost,
 550                                       u8 event_id, char *msg)
 551 {
 552         struct mlx5_fw_trace_data *trace_data;
 553
 554         mutex_lock(&tracer->st_arr.lock);
 555         trace_data = &tracer->st_arr.straces[tracer->st_arr.saved_traces_index];
 556         trace_data->timestamp = timestamp;
 557         trace_data->lost = lost;
 558         trace_data->event_id = event_id;
 559         strscpy_pad(trace_data->msg, msg, TRACE_STR_MSG);
 560
 561         tracer->st_arr.saved_traces_index =
 562                 (tracer->st_arr.saved_traces_index + 1) & (SAVED_TRACES_NUM - 1);
 563         mutex_unlock(&tracer->st_arr.lock);
 564 }
 565
 566 static noinline
 567 void mlx5_tracer_print_trace(struct tracer_string_format *str_frmt,
 568                              struct mlx5_core_dev *dev,
 569                              u64 trace_timestamp)
 570 {
 571         char    tmp[512];
 572
 573         snprintf(tmp, sizeof(tmp), str_frmt->string,
 574                  str_frmt->params[0],
 575                  str_frmt->params[1],
 576                  str_frmt->params[2],
 577                  str_frmt->params[3],
 578                  str_frmt->params[4],
 579                  str_frmt->params[5],
 580                  str_frmt->params[6]);
 581
 582         trace_mlx5_fw(dev->tracer, trace_timestamp, str_frmt->lost,
 583                       str_frmt->event_id, tmp);
 584
 585         mlx5_fw_tracer_save_trace(dev->tracer, trace_timestamp,
 586                                   str_frmt->lost, str_frmt->event_id, tmp);
 587
 588         /* remove it from hash */
 589         mlx5_tracer_clean_message(str_frmt);
 590 }
 591
 592 static int mlx5_tracer_handle_raw_string(struct mlx5_fw_tracer *tracer,
 593                                          struct tracer_event *tracer_event)
 594 {
 595         struct tracer_string_format *cur_string;
 596
 597         cur_string = mlx5_tracer_message_insert(tracer, tracer_event);
 598         if (!cur_string)
 599                 return -1;
 600
 601         cur_string->event_id = tracer_event->event_id;
 602         cur_string->timestamp = tracer_event->string_event.timestamp;
 603         cur_string->lost = tracer_event->lost_event;
 604         cur_string->string = "0x%08x%08x";
 605         cur_string->num_of_params = 2;
 606         cur_string->params[0] = upper_32_bits(*tracer_event->out);
 607         cur_string->params[1] = lower_32_bits(*tracer_event->out);
 608         list_add_tail(&cur_string->list, &tracer->ready_strings_list);
 609         return 0;
 610 }
 611
 612 static int mlx5_tracer_handle_string_trace(struct mlx5_fw_tracer *tracer,
 613                                            struct tracer_event *tracer_event)
 614 {
 615         struct tracer_string_format *cur_string;
 616
 617         if (tracer_event->string_event.tdsn == 0) {
 618                 cur_string = mlx5_tracer_get_string(tracer, tracer_event);
 619                 if (!cur_string)
 620                         return mlx5_tracer_handle_raw_string(tracer, tracer_event);
 621
 622                 cur_string->num_of_params = mlx5_tracer_get_num_of_params(cur_string->string);
 623                 cur_string->last_param_num = 0;
 624                 cur_string->event_id = tracer_event->event_id;
 625                 cur_string->tmsn = tracer_event->string_event.tmsn;
 626                 cur_string->timestamp = tracer_event->string_event.timestamp;
 627                 cur_string->lost = tracer_event->lost_event;
 628                 if (cur_string->num_of_params == 0) /* trace with no params */
 629                         list_add_tail(&cur_string->list, &tracer->ready_strings_list);
 630         } else {
 631                 cur_string = mlx5_tracer_message_get(tracer, tracer_event);
 632                 if (!cur_string) {
 633                         pr_debug("%s Got string event for unknown string tmsn: %d\n",
 634                                  __func__, tracer_event->string_event.tmsn);
 635                         return mlx5_tracer_handle_raw_string(tracer, tracer_event);
 636                 }
 637                 cur_string->last_param_num += 1;
 638                 if (cur_string->last_param_num > TRACER_MAX_PARAMS) {
 639                         pr_debug("%s Number of params exceeds the max (%d)\n",
 640                                  __func__, TRACER_MAX_PARAMS);
 641                         list_add_tail(&cur_string->list, &tracer->ready_strings_list);
 642                         return 0;
 643                 }
 644                 /* keep the new parameter */
 645                 cur_string->params[cur_string->last_param_num - 1] =
 646                         tracer_event->string_event.string_param;
 647                 if (cur_string->last_param_num == cur_string->num_of_params)
 648                         list_add_tail(&cur_string->list, &tracer->ready_strings_list);
 649         }
 650
 651         return 0;
 652 }
 653
 654 static void mlx5_tracer_handle_timestamp_trace(struct mlx5_fw_tracer *tracer,
 655                                                struct tracer_event *tracer_event)
 656 {
 657         struct tracer_timestamp_event timestamp_event =
 658                                                 tracer_event->timestamp_event;
 659         struct tracer_string_format *str_frmt, *tmp_str;
 660         struct mlx5_core_dev *dev = tracer->dev;
 661         u64 trace_timestamp;
 662
 663         list_for_each_entry_safe(str_frmt, tmp_str, &tracer->ready_strings_list, list) {
 664                 list_del(&str_frmt->list);
 665                 if (str_frmt->timestamp < (timestamp_event.timestamp & MASK_6_0))
 666                         trace_timestamp = (timestamp_event.timestamp & MASK_52_7) |
 667                                           (str_frmt->timestamp & MASK_6_0);
 668                 else
 669                         trace_timestamp = ((timestamp_event.timestamp - 1) & MASK_52_7) |
 670                                           (str_frmt->timestamp & MASK_6_0);
 671
 672                 mlx5_tracer_print_trace(str_frmt, dev, trace_timestamp);
 673         }
 674 }
 675
 676 static int mlx5_tracer_handle_trace(struct mlx5_fw_tracer *tracer,
 677                                     struct tracer_event *tracer_event)
 678 {
 679         if (tracer_event->type == TRACER_EVENT_TYPE_STRING) {
 680                 mlx5_tracer_handle_string_trace(tracer, tracer_event);
 681         } else if (tracer_event->type == TRACER_EVENT_TYPE_TIMESTAMP) {
 682                 if (!tracer_event->timestamp_event.unreliable)
 683                         mlx5_tracer_handle_timestamp_trace(tracer, tracer_event);
 684         } else {
 685                 pr_debug("%s Got unrecognised type %d for parsing, exiting..\n",
 686                          __func__, tracer_event->type);
 687         }
 688         return 0;
 689 }
 690
 691 static void mlx5_fw_tracer_handle_traces(struct work_struct *work)
 692 {
 693         struct mlx5_fw_tracer *tracer =
 694                         container_of(work, struct mlx5_fw_tracer, handle_traces_work);
 695         u64 block_timestamp, last_block_timestamp, tmp_trace_block[TRACES_PER_BLOCK];
 696         u32 block_count, start_offset, prev_start_offset, prev_consumer_index;
 697         u32 trace_event_size = MLX5_ST_SZ_BYTES(tracer_event);
 698         struct mlx5_core_dev *dev = tracer->dev;
 699         struct tracer_event tracer_event;
 700         int i;
 701
 702         mlx5_core_dbg(dev, "FWTracer: Handle Trace event, owner=(%d)\n", tracer->owner);
 703         if (!tracer->owner)
 704                 return;
 705
 706         if (unlikely(!tracer->str_db.loaded))
 707                 goto arm;
 708
 709         block_count = tracer->buff.size / TRACER_BLOCK_SIZE_BYTE;
 710         start_offset = tracer->buff.consumer_index * TRACER_BLOCK_SIZE_BYTE;
 711
 712         /* Copy the block to local buffer to avoid HW override while being processed */
 713         memcpy(tmp_trace_block, tracer->buff.log_buf + start_offset,
 714                TRACER_BLOCK_SIZE_BYTE);
 715
 716         block_timestamp =
 717                 get_block_timestamp(tracer, &tmp_trace_block[TRACES_PER_BLOCK - 1]);
 718
 719         while (block_timestamp > tracer->last_timestamp) {
 720                 /* Check block override if it's not the first block */
 721                 if (!tracer->last_timestamp) {
 722                         u64 *ts_event;
 723                         /* To avoid block override be the HW in case of buffer
 724                          * wraparound, the time stamp of the previous block
 725                          * should be compared to the last timestamp handled
 726                          * by the driver.
 727                          */
 728                         prev_consumer_index =
 729                                 (tracer->buff.consumer_index - 1) & (block_count - 1);
 730                         prev_start_offset = prev_consumer_index * TRACER_BLOCK_SIZE_BYTE;
 731
 732                         ts_event = tracer->buff.log_buf + prev_start_offset +
 733                                    (TRACES_PER_BLOCK - 1) * trace_event_size;
 734                         last_block_timestamp = get_block_timestamp(tracer, ts_event);
 735                         /* If previous timestamp different from last stored
 736                          * timestamp then there is a good chance that the
 737                          * current buffer is overwritten and therefore should
 738                          * not be parsed.
 739                          */
 740                         if (tracer->last_timestamp != last_block_timestamp) {
 741                                 mlx5_core_warn(dev, "FWTracer: Events were lost\n");
 742                                 tracer->last_timestamp = block_timestamp;
 743                                 tracer->buff.consumer_index =
 744                                         (tracer->buff.consumer_index + 1) & (block_count - 1);
 745                                 break;
 746                         }
 747                 }
 748
 749                 /* Parse events */
 750                 for (i = 0; i < TRACES_PER_BLOCK ; i++) {
 751                         poll_trace(tracer, &tracer_event, &tmp_trace_block[i]);
 752                         mlx5_tracer_handle_trace(tracer, &tracer_event);
 753                 }
 754
 755                 tracer->buff.consumer_index =
 756                         (tracer->buff.consumer_index + 1) & (block_count - 1);
 757
 758                 tracer->last_timestamp = block_timestamp;
 759                 start_offset = tracer->buff.consumer_index * TRACER_BLOCK_SIZE_BYTE;
 760                 memcpy(tmp_trace_block, tracer->buff.log_buf + start_offset,
 761                        TRACER_BLOCK_SIZE_BYTE);
 762                 block_timestamp = get_block_timestamp(tracer,
 763                                                       &tmp_trace_block[TRACES_PER_BLOCK - 1]);
 764         }
 765
 766 arm:
 767         mlx5_fw_tracer_arm(dev);
 768 }
 769
 770 static int mlx5_fw_tracer_set_mtrc_conf(struct mlx5_fw_tracer *tracer)
 771 {
 772         struct mlx5_core_dev *dev = tracer->dev;
 773         u32 out[MLX5_ST_SZ_DW(mtrc_conf)] = {0};
 774         u32 in[MLX5_ST_SZ_DW(mtrc_conf)] = {0};
 775         int err;
 776
 777         MLX5_SET(mtrc_conf, in, trace_mode, TRACE_TO_MEMORY);
 778         MLX5_SET(mtrc_conf, in, log_trace_buffer_size,
 779                  ilog2(TRACER_BUFFER_PAGE_NUM));
 780         MLX5_SET(mtrc_conf, in, trace_mkey, tracer->buff.mkey);
 781
 782         err = mlx5_core_access_reg(dev, in, sizeof(in), out, sizeof(out),
 783                                    MLX5_REG_MTRC_CONF, 0, 1);
 784         if (err)
 785                 mlx5_core_warn(dev, "FWTracer: Failed to set tracer configurations %d\n", err);
 786
 787         tracer->buff.consumer_index = 0;
 788         return err;
 789 }
 790
 791 static int mlx5_fw_tracer_set_mtrc_ctrl(struct mlx5_fw_tracer *tracer, u8 status, u8 arm)
 792 {
 793         struct mlx5_core_dev *dev = tracer->dev;
 794         u32 out[MLX5_ST_SZ_DW(mtrc_ctrl)] = {0};
 795         u32 in[MLX5_ST_SZ_DW(mtrc_ctrl)] = {0};
 796         int err;
 797
 798         MLX5_SET(mtrc_ctrl, in, modify_field_select, TRACE_STATUS);
 799         MLX5_SET(mtrc_ctrl, in, trace_status, status);
 800         MLX5_SET(mtrc_ctrl, in, arm_event, arm);
 801
 802         err = mlx5_core_access_reg(dev, in, sizeof(in), out, sizeof(out),
 803                                    MLX5_REG_MTRC_CTRL, 0, 1);
 804
 805         if (!err && status)
 806                 tracer->last_timestamp = 0;
 807
 808         return err;
 809 }
 810
 811 static int mlx5_fw_tracer_start(struct mlx5_fw_tracer *tracer)
 812 {
 813         struct mlx5_core_dev *dev = tracer->dev;
 814         int err;
 815
 816         err = mlx5_fw_tracer_ownership_acquire(tracer);
 817         if (err) {
 818                 mlx5_core_dbg(dev, "FWTracer: Ownership was not granted %d\n", err);
 819                 /* Don't fail since ownership can be acquired on a later FW event */
 820                 return 0;
 821         }
 822
 823         err = mlx5_fw_tracer_set_mtrc_conf(tracer);
 824         if (err) {
 825                 mlx5_core_warn(dev, "FWTracer: Failed to set tracer configuration %d\n", err);
 826                 goto release_ownership;
 827         }
 828
 829         /* enable tracer & trace events */
 830         err = mlx5_fw_tracer_set_mtrc_ctrl(tracer, 1, 1);
 831         if (err) {
 832                 mlx5_core_warn(dev, "FWTracer: Failed to enable tracer %d\n", err);
 833                 goto release_ownership;
 834         }
 835
 836         mlx5_core_dbg(dev, "FWTracer: Ownership granted and active\n");
 837         return 0;
 838
 839 release_ownership:
 840         mlx5_fw_tracer_ownership_release(tracer);
 841         return err;
 842 }
 843
 844 static void mlx5_fw_tracer_ownership_change(struct work_struct *work)
 845 {
 846         struct mlx5_fw_tracer *tracer =
 847                 container_of(work, struct mlx5_fw_tracer, ownership_change_work);
 848
 849         mlx5_core_dbg(tracer->dev, "FWTracer: ownership changed, current=(%d)\n", tracer->owner);
 850         if (tracer->owner) {
 851                 tracer->owner = false;
 852                 return;
 853         }
 854
 855         mlx5_fw_tracer_start(tracer);
 856 }
 857
 858 static int mlx5_fw_tracer_set_core_dump_reg(struct mlx5_core_dev *dev,
 859                                             u32 *in, int size_in)
 860 {
 861         u32 out[MLX5_ST_SZ_DW(core_dump_reg)] = {};
 862
 863         if (!MLX5_CAP_DEBUG(dev, core_dump_general) &&
 864             !MLX5_CAP_DEBUG(dev, core_dump_qp))
 865                 return -EOPNOTSUPP;
 866
 867         return mlx5_core_access_reg(dev, in, size_in, out, sizeof(out),
 868                                     MLX5_REG_CORE_DUMP, 0, 1);
 869 }
 870
 871 int mlx5_fw_tracer_trigger_core_dump_general(struct mlx5_core_dev *dev)
 872 {
 873         struct mlx5_fw_tracer *tracer = dev->tracer;
 874         u32 in[MLX5_ST_SZ_DW(core_dump_reg)] = {};
 875         int err;
 876
 877         if (!MLX5_CAP_DEBUG(dev, core_dump_general) || !tracer)
 878                 return -EOPNOTSUPP;
 879         if (!tracer->owner)
 880                 return -EPERM;
 881
 882         MLX5_SET(core_dump_reg, in, core_dump_type, 0x0);
 883
 884         err =  mlx5_fw_tracer_set_core_dump_reg(dev, in, sizeof(in));
 885         if (err)
 886                 return err;
 887         queue_work(tracer->work_queue, &tracer->handle_traces_work);
 888         flush_workqueue(tracer->work_queue);
 889         return 0;
 890 }
 891
 892 static int
 893 mlx5_devlink_fmsg_fill_trace(struct devlink_fmsg *fmsg,
 894                              struct mlx5_fw_trace_data *trace_data)
 895 {
 896         int err;
 897
 898         err = devlink_fmsg_obj_nest_start(fmsg);
 899         if (err)
 900                 return err;
 901
 902         err = devlink_fmsg_u64_pair_put(fmsg, "timestamp", trace_data->timestamp);
 903         if (err)
 904                 return err;
 905
 906         err = devlink_fmsg_bool_pair_put(fmsg, "lost", trace_data->lost);
 907         if (err)
 908                 return err;
 909
 910         err = devlink_fmsg_u8_pair_put(fmsg, "event_id", trace_data->event_id);
 911         if (err)
 912                 return err;
 913
 914         err = devlink_fmsg_string_pair_put(fmsg, "msg", trace_data->msg);
 915         if (err)
 916                 return err;
 917
 918         err = devlink_fmsg_obj_nest_end(fmsg);
 919         if (err)
 920                 return err;
 921         return 0;
 922 }
 923
 924 int mlx5_fw_tracer_get_saved_traces_objects(struct mlx5_fw_tracer *tracer,
 925                                             struct devlink_fmsg *fmsg)
 926 {
 927         struct mlx5_fw_trace_data *straces = tracer->st_arr.straces;
 928         u32 index, start_index, end_index;
 929         u32 saved_traces_index;
 930         int err;
 931
 932         if (!straces[0].timestamp)
 933                 return -ENOMSG;
 934
 935         mutex_lock(&tracer->st_arr.lock);
 936         saved_traces_index = tracer->st_arr.saved_traces_index;
 937         if (straces[saved_traces_index].timestamp)
 938                 start_index = saved_traces_index;
 939         else
 940                 start_index = 0;
 941         end_index = (saved_traces_index - 1) & (SAVED_TRACES_NUM - 1);
 942
 943         err = devlink_fmsg_arr_pair_nest_start(fmsg, "dump fw traces");
 944         if (err)
 945                 goto unlock;
 946         index = start_index;
 947         while (index != end_index) {
 948                 err = mlx5_devlink_fmsg_fill_trace(fmsg, &straces[index]);
 949                 if (err)
 950                         goto unlock;
 951
 952                 index = (index + 1) & (SAVED_TRACES_NUM - 1);
 953         }
 954
 955         err = devlink_fmsg_arr_pair_nest_end(fmsg);
 956 unlock:
 957         mutex_unlock(&tracer->st_arr.lock);
 958         return err;
 959 }
 960
 961 static void mlx5_fw_tracer_update_db(struct work_struct *work)
 962 {
 963         struct mlx5_fw_tracer *tracer =
 964                         container_of(work, struct mlx5_fw_tracer, update_db_work);
 965
 966         mlx5_fw_tracer_reload(tracer);
 967 }
 968
 969 /* Create software resources (Buffers, etc ..) */
 970 struct mlx5_fw_tracer *mlx5_fw_tracer_create(struct mlx5_core_dev *dev)
 971 {
 972         struct mlx5_fw_tracer *tracer = NULL;
 973         int err;
 974
 975         if (!MLX5_CAP_MCAM_REG(dev, tracer_registers)) {
 976                 mlx5_core_dbg(dev, "FWTracer: Tracer capability not present\n");
 977                 return NULL;
 978         }
 979
 980         tracer = kvzalloc(sizeof(*tracer), GFP_KERNEL);
 981         if (!tracer)
 982                 return ERR_PTR(-ENOMEM);
 983
 984         tracer->work_queue = create_singlethread_workqueue("mlx5_fw_tracer");
 985         if (!tracer->work_queue) {
 986                 err = -ENOMEM;
 987                 goto free_tracer;
 988         }
 989
 990         tracer->dev = dev;
 991
 992         INIT_LIST_HEAD(&tracer->ready_strings_list);
 993         INIT_WORK(&tracer->ownership_change_work, mlx5_fw_tracer_ownership_change);
 994         INIT_WORK(&tracer->read_fw_strings_work, mlx5_tracer_read_strings_db);
 995         INIT_WORK(&tracer->handle_traces_work, mlx5_fw_tracer_handle_traces);
 996         INIT_WORK(&tracer->update_db_work, mlx5_fw_tracer_update_db);
 997         mutex_init(&tracer->state_lock);
 998
 999
1000         err = mlx5_query_mtrc_caps(tracer);
1001         if (err) {
1002                 mlx5_core_dbg(dev, "FWTracer: Failed to query capabilities %d\n", err);
1003                 goto destroy_workqueue;
1004         }
1005
1006         err = mlx5_fw_tracer_create_log_buf(tracer);
1007         if (err) {
1008                 mlx5_core_warn(dev, "FWTracer: Create log buffer failed %d\n", err);
1009                 goto destroy_workqueue;
1010         }
1011
1012         err = mlx5_fw_tracer_allocate_strings_db(tracer);
1013         if (err) {
1014                 mlx5_core_warn(dev, "FWTracer: Allocate strings database failed %d\n", err);
1015                 goto free_log_buf;
1016         }
1017
1018         mlx5_fw_tracer_init_saved_traces_array(tracer);
1019         mlx5_core_dbg(dev, "FWTracer: Tracer created\n");
1020
1021         return tracer;
1022
1023 free_log_buf:
1024         mlx5_fw_tracer_destroy_log_buf(tracer);
1025 destroy_workqueue:
1026         tracer->dev = NULL;
1027         destroy_workqueue(tracer->work_queue);
1028 free_tracer:
1029         kvfree(tracer);
1030         return ERR_PTR(err);
1031 }
1032
1033 static int fw_tracer_event(struct notifier_block *nb, unsigned long action, void *data);
1034
1035 /* Create HW resources + start tracer */
1036 int mlx5_fw_tracer_init(struct mlx5_fw_tracer *tracer)
1037 {
1038         struct mlx5_core_dev *dev;
1039         int err;
1040
1041         if (IS_ERR_OR_NULL(tracer))
1042                 return 0;
1043
1044         if (!tracer->str_db.loaded)
1045                 queue_work(tracer->work_queue, &tracer->read_fw_strings_work);
1046
1047         mutex_lock(&tracer->state_lock);
1048         if (test_and_set_bit(MLX5_TRACER_STATE_UP, &tracer->state))
1049                 goto unlock;
1050
1051         dev = tracer->dev;
1052
1053         err = mlx5_core_alloc_pd(dev, &tracer->buff.pdn);
1054         if (err) {
1055                 mlx5_core_warn(dev, "FWTracer: Failed to allocate PD %d\n", err);
1056                 goto err_cancel_work;
1057         }
1058
1059         err = mlx5_fw_tracer_create_mkey(tracer);
1060         if (err) {
1061                 mlx5_core_warn(dev, "FWTracer: Failed to create mkey %d\n", err);
1062                 goto err_dealloc_pd;
1063         }
1064
1065         MLX5_NB_INIT(&tracer->nb, fw_tracer_event, DEVICE_TRACER);
1066         mlx5_eq_notifier_register(dev, &tracer->nb);
1067
1068         err = mlx5_fw_tracer_start(tracer);
1069         if (err) {
1070                 mlx5_core_warn(dev, "FWTracer: Failed to start tracer %d\n", err);
1071                 goto err_notifier_unregister;
1072         }
1073 unlock:
1074         mutex_unlock(&tracer->state_lock);
1075         return 0;
1076
1077 err_notifier_unregister:
1078         mlx5_eq_notifier_unregister(dev, &tracer->nb);
1079         mlx5_core_destroy_mkey(dev, tracer->buff.mkey);
1080 err_dealloc_pd:
1081         mlx5_core_dealloc_pd(dev, tracer->buff.pdn);
1082 err_cancel_work:
1083         cancel_work_sync(&tracer->read_fw_strings_work);
1084         mutex_unlock(&tracer->state_lock);
1085         return err;
1086 }
1087
1088 /* Stop tracer + Cleanup HW resources */
1089 void mlx5_fw_tracer_cleanup(struct mlx5_fw_tracer *tracer)
1090 {
1091         if (IS_ERR_OR_NULL(tracer))
1092                 return;
1093
1094         mutex_lock(&tracer->state_lock);
1095         if (!test_and_clear_bit(MLX5_TRACER_STATE_UP, &tracer->state))
1096                 goto unlock;
1097
1098         mlx5_core_dbg(tracer->dev, "FWTracer: Cleanup, is owner ? (%d)\n",
1099                       tracer->owner);
1100         mlx5_eq_notifier_unregister(tracer->dev, &tracer->nb);
1101         cancel_work_sync(&tracer->ownership_change_work);
1102         cancel_work_sync(&tracer->handle_traces_work);
1103         /* It is valid to get here from update_db_work. Hence, don't wait for
1104          * update_db_work to finished.
1105          */
1106         cancel_work(&tracer->update_db_work);
1107
1108         if (tracer->owner)
1109                 mlx5_fw_tracer_ownership_release(tracer);
1110
1111         mlx5_core_destroy_mkey(tracer->dev, tracer->buff.mkey);
1112         mlx5_core_dealloc_pd(tracer->dev, tracer->buff.pdn);
1113 unlock:
1114         mutex_unlock(&tracer->state_lock);
1115 }
1116
1117 /* Free software resources (Buffers, etc ..) */
1118 void mlx5_fw_tracer_destroy(struct mlx5_fw_tracer *tracer)
1119 {
1120         if (IS_ERR_OR_NULL(tracer))
1121                 return;
1122
1123         mlx5_core_dbg(tracer->dev, "FWTracer: Destroy\n");
1124
1125         cancel_work_sync(&tracer->read_fw_strings_work);
1126         mlx5_fw_tracer_clean_ready_list(tracer);
1127         mlx5_fw_tracer_clean_print_hash(tracer);
1128         mlx5_fw_tracer_clean_saved_traces_array(tracer);
1129         mlx5_fw_tracer_free_strings_db(tracer);
1130         mlx5_fw_tracer_destroy_log_buf(tracer);
1131         mutex_destroy(&tracer->state_lock);
1132         destroy_workqueue(tracer->work_queue);
1133         kvfree(tracer);
1134 }
1135
1136 static int mlx5_fw_tracer_recreate_strings_db(struct mlx5_fw_tracer *tracer)
1137 {
1138         struct mlx5_core_dev *dev;
1139         int err;
1140
1141         if (test_and_set_bit(MLX5_TRACER_RECREATE_DB, &tracer->state))
1142                 return 0;
1143         cancel_work_sync(&tracer->read_fw_strings_work);
1144         mlx5_fw_tracer_clean_ready_list(tracer);
1145         mlx5_fw_tracer_clean_print_hash(tracer);
1146         mlx5_fw_tracer_clean_saved_traces_array(tracer);
1147         mlx5_fw_tracer_free_strings_db(tracer);
1148
1149         dev = tracer->dev;
1150         err = mlx5_query_mtrc_caps(tracer);
1151         if (err) {
1152                 mlx5_core_dbg(dev, "FWTracer: Failed to query capabilities %d\n", err);
1153                 goto out;
1154         }
1155
1156         err = mlx5_fw_tracer_allocate_strings_db(tracer);
1157         if (err) {
1158                 mlx5_core_warn(dev, "FWTracer: Allocate strings DB failed %d\n", err);
1159                 goto out;
1160         }
1161         mlx5_fw_tracer_init_saved_traces_array(tracer);
1162 out:
1163         clear_bit(MLX5_TRACER_RECREATE_DB, &tracer->state);
1164         return err;
1165 }
1166
1167 int mlx5_fw_tracer_reload(struct mlx5_fw_tracer *tracer)
1168 {
1169         struct mlx5_core_dev *dev;
1170         int err;
1171
1172         if (IS_ERR_OR_NULL(tracer))
1173                 return 0;
1174
1175         dev = tracer->dev;
1176         mlx5_fw_tracer_cleanup(tracer);
1177         err = mlx5_fw_tracer_recreate_strings_db(tracer);
1178         if (err) {
1179                 mlx5_core_warn(dev, "Failed to recreate FW tracer strings DB\n");
1180                 return err;
1181         }
1182         err = mlx5_fw_tracer_init(tracer);
1183         if (err) {
1184                 mlx5_core_warn(dev, "Failed to re-initialize FW tracer\n");
1185                 return err;
1186         }
1187
1188         return 0;
1189 }
1190
1191 static int fw_tracer_event(struct notifier_block *nb, unsigned long action, void *data)
1192 {
1193         struct mlx5_fw_tracer *tracer = mlx5_nb_cof(nb, struct mlx5_fw_tracer, nb);
1194         struct mlx5_core_dev *dev = tracer->dev;
1195         struct mlx5_eqe *eqe = data;
1196
1197         switch (eqe->sub_type) {
1198         case MLX5_TRACER_SUBTYPE_OWNERSHIP_CHANGE:
1199                 queue_work(tracer->work_queue, &tracer->ownership_change_work);
1200                 break;
1201         case MLX5_TRACER_SUBTYPE_TRACES_AVAILABLE:
1202                 queue_work(tracer->work_queue, &tracer->handle_traces_work);
1203                 break;
1204         case MLX5_TRACER_SUBTYPE_STRINGS_DB_UPDATE:
1205                 queue_work(tracer->work_queue, &tracer->update_db_work);
1206                 break;
1207         default:
1208                 mlx5_core_dbg(dev, "FWTracer: Event with unrecognized subtype: sub_type %d\n",
1209                               eqe->sub_type);
1210         }
1211
1212         return NOTIFY_OK;
1213 }
1214
1215 EXPORT_TRACEPOINT_SYMBOL(mlx5_fw);