1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. 4 */ 5 6 #include <linux/cleanup.h> 7 #include <linux/debugfs.h> 8 #include <linux/dma-mapping.h> 9 #include <linux/slab.h> 10 #include <linux/uaccess.h> 11 12 #include <soc/tegra/bpmp.h> 13 #include <soc/tegra/bpmp-abi.h> 14 15 static DEFINE_MUTEX(bpmp_debug_lock); 16 17 struct seqbuf { 18 char *buf; 19 size_t pos; 20 size_t size; 21 }; 22 23 static void seqbuf_init(struct seqbuf *seqbuf, void *buf, size_t size) 24 { 25 seqbuf->buf = buf; 26 seqbuf->size = size; 27 seqbuf->pos = 0; 28 } 29 30 static size_t seqbuf_avail(struct seqbuf *seqbuf) 31 { 32 return seqbuf->pos < seqbuf->size ? seqbuf->size - seqbuf->pos : 0; 33 } 34 35 static size_t seqbuf_status(struct seqbuf *seqbuf) 36 { 37 return seqbuf->pos <= seqbuf->size ? 0 : -EOVERFLOW; 38 } 39 40 static int seqbuf_eof(struct seqbuf *seqbuf) 41 { 42 return seqbuf->pos >= seqbuf->size; 43 } 44 45 static int seqbuf_read(struct seqbuf *seqbuf, void *buf, size_t nbyte) 46 { 47 nbyte = min(nbyte, seqbuf_avail(seqbuf)); 48 memcpy(buf, seqbuf->buf + seqbuf->pos, nbyte); 49 seqbuf->pos += nbyte; 50 return seqbuf_status(seqbuf); 51 } 52 53 static int seqbuf_read_u32(struct seqbuf *seqbuf, u32 *v) 54 { 55 return seqbuf_read(seqbuf, v, 4); 56 } 57 58 static int seqbuf_read_str(struct seqbuf *seqbuf, const char **str) 59 { 60 *str = seqbuf->buf + seqbuf->pos; 61 seqbuf->pos += strnlen(*str, seqbuf_avail(seqbuf)); 62 seqbuf->pos++; 63 return seqbuf_status(seqbuf); 64 } 65 66 static void seqbuf_seek(struct seqbuf *seqbuf, ssize_t offset) 67 { 68 seqbuf->pos += offset; 69 } 70 71 /* map filename in Linux debugfs to corresponding entry in BPMP */ 72 static const char *get_filename(struct tegra_bpmp *bpmp, 73 const struct file *file, char *buf, int size) 74 { 75 const char *root_path, *filename = NULL; 76 char *root_path_buf; 77 size_t root_len; 78 size_t root_path_buf_len = 512; 79 80 root_path_buf = kzalloc(root_path_buf_len, GFP_KERNEL); 81 if (!root_path_buf) 82 return NULL; 83 84 root_path = dentry_path(bpmp->debugfs_mirror, root_path_buf, 85 root_path_buf_len); 86 if (IS_ERR(root_path)) 87 goto out; 88 89 root_len = strlen(root_path); 90 91 filename = dentry_path(file->f_path.dentry, buf, size); 92 if (IS_ERR(filename)) { 93 filename = NULL; 94 goto out; 95 } 96 97 if (strlen(filename) < root_len || strncmp(filename, root_path, root_len)) { 98 filename = NULL; 99 goto out; 100 } 101 102 filename += root_len; 103 104 out: 105 kfree(root_path_buf); 106 return filename; 107 } 108 109 static int mrq_debug_open(struct tegra_bpmp *bpmp, const char *name, 110 u32 *fd, u32 *len, bool write) 111 { 112 struct mrq_debug_request req = { 113 .cmd = write ? CMD_DEBUG_OPEN_WO : CMD_DEBUG_OPEN_RO, 114 }; 115 struct mrq_debug_response resp; 116 struct tegra_bpmp_message msg = { 117 .mrq = MRQ_DEBUG, 118 .tx = { 119 .data = &req, 120 .size = sizeof(req), 121 }, 122 .rx = { 123 .data = &resp, 124 .size = sizeof(resp), 125 }, 126 }; 127 ssize_t sz_name; 128 int err = 0; 129 130 sz_name = strscpy(req.fop.name, name, sizeof(req.fop.name)); 131 if (sz_name < 0) { 132 pr_err("File name too large: %s\n", name); 133 return -EINVAL; 134 } 135 136 err = tegra_bpmp_transfer(bpmp, &msg); 137 if (err < 0) 138 return err; 139 else if (msg.rx.ret < 0) 140 return -EINVAL; 141 142 *len = resp.fop.datalen; 143 *fd = resp.fop.fd; 144 145 return 0; 146 } 147 148 static int mrq_debug_close(struct tegra_bpmp *bpmp, u32 fd) 149 { 150 struct mrq_debug_request req = { 151 .cmd = CMD_DEBUG_CLOSE, 152 .frd = { 153 .fd = fd, 154 }, 155 }; 156 struct mrq_debug_response resp; 157 struct tegra_bpmp_message msg = { 158 .mrq = MRQ_DEBUG, 159 .tx = { 160 .data = &req, 161 .size = sizeof(req), 162 }, 163 .rx = { 164 .data = &resp, 165 .size = sizeof(resp), 166 }, 167 }; 168 int err = 0; 169 170 err = tegra_bpmp_transfer(bpmp, &msg); 171 if (err < 0) 172 return err; 173 else if (msg.rx.ret < 0) 174 return -EINVAL; 175 176 return 0; 177 } 178 179 static int mrq_debug_read(struct tegra_bpmp *bpmp, const char *name, 180 char *data, size_t sz_data, u32 *nbytes) 181 { 182 struct mrq_debug_request req = { 183 .cmd = CMD_DEBUG_READ, 184 }; 185 struct mrq_debug_response resp; 186 struct tegra_bpmp_message msg = { 187 .mrq = MRQ_DEBUG, 188 .tx = { 189 .data = &req, 190 .size = sizeof(req), 191 }, 192 .rx = { 193 .data = &resp, 194 .size = sizeof(resp), 195 }, 196 }; 197 u32 fd = 0, len = 0; 198 int remaining, err, close_err; 199 200 mutex_lock(&bpmp_debug_lock); 201 err = mrq_debug_open(bpmp, name, &fd, &len, 0); 202 if (err) 203 goto out; 204 205 if (len > sz_data) { 206 err = -EFBIG; 207 goto close; 208 } 209 210 req.frd.fd = fd; 211 remaining = len; 212 213 while (remaining > 0) { 214 err = tegra_bpmp_transfer(bpmp, &msg); 215 if (err < 0) { 216 goto close; 217 } else if (msg.rx.ret < 0) { 218 err = -EINVAL; 219 goto close; 220 } 221 222 if (resp.frd.readlen > remaining) { 223 pr_err("%s: read data length invalid\n", __func__); 224 err = -EINVAL; 225 goto close; 226 } 227 228 memcpy(data, resp.frd.data, resp.frd.readlen); 229 data += resp.frd.readlen; 230 remaining -= resp.frd.readlen; 231 } 232 233 *nbytes = len; 234 235 close: 236 close_err = mrq_debug_close(bpmp, fd); 237 if (!err) 238 err = close_err; 239 out: 240 mutex_unlock(&bpmp_debug_lock); 241 return err; 242 } 243 244 static int mrq_debug_write(struct tegra_bpmp *bpmp, const char *name, 245 uint8_t *data, size_t sz_data) 246 { 247 struct mrq_debug_request req = { 248 .cmd = CMD_DEBUG_WRITE 249 }; 250 struct mrq_debug_response resp; 251 struct tegra_bpmp_message msg = { 252 .mrq = MRQ_DEBUG, 253 .tx = { 254 .data = &req, 255 .size = sizeof(req), 256 }, 257 .rx = { 258 .data = &resp, 259 .size = sizeof(resp), 260 }, 261 }; 262 u32 fd = 0, len = 0; 263 size_t remaining; 264 int err; 265 266 mutex_lock(&bpmp_debug_lock); 267 err = mrq_debug_open(bpmp, name, &fd, &len, 1); 268 if (err) 269 goto out; 270 271 if (sz_data > len) { 272 err = -EINVAL; 273 goto close; 274 } 275 276 req.fwr.fd = fd; 277 remaining = sz_data; 278 279 while (remaining > 0) { 280 len = min(remaining, sizeof(req.fwr.data)); 281 memcpy(req.fwr.data, data, len); 282 req.fwr.datalen = len; 283 284 err = tegra_bpmp_transfer(bpmp, &msg); 285 if (err < 0) { 286 goto close; 287 } else if (msg.rx.ret < 0) { 288 err = -EINVAL; 289 goto close; 290 } 291 292 data += req.fwr.datalen; 293 remaining -= req.fwr.datalen; 294 } 295 296 close: 297 err = mrq_debug_close(bpmp, fd); 298 out: 299 mutex_unlock(&bpmp_debug_lock); 300 return err; 301 } 302 303 static int bpmp_debug_show(struct seq_file *m, void *p) 304 { 305 struct file *file = m->private; 306 struct inode *inode = file_inode(file); 307 struct tegra_bpmp *bpmp = inode->i_private; 308 char fnamebuf[256]; 309 const char *filename; 310 struct mrq_debug_request req = { 311 .cmd = CMD_DEBUG_READ, 312 }; 313 struct mrq_debug_response resp; 314 struct tegra_bpmp_message msg = { 315 .mrq = MRQ_DEBUG, 316 .tx = { 317 .data = &req, 318 .size = sizeof(req), 319 }, 320 .rx = { 321 .data = &resp, 322 .size = sizeof(resp), 323 }, 324 }; 325 u32 fd = 0, len = 0; 326 int remaining, err, close_err; 327 328 filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf)); 329 if (!filename) 330 return -ENOENT; 331 332 mutex_lock(&bpmp_debug_lock); 333 err = mrq_debug_open(bpmp, filename, &fd, &len, 0); 334 if (err) 335 goto out; 336 337 req.frd.fd = fd; 338 remaining = len; 339 340 while (remaining > 0) { 341 err = tegra_bpmp_transfer(bpmp, &msg); 342 if (err < 0) { 343 goto close; 344 } else if (msg.rx.ret < 0) { 345 err = -EINVAL; 346 goto close; 347 } 348 349 if (resp.frd.readlen > remaining) { 350 pr_err("%s: read data length invalid\n", __func__); 351 err = -EINVAL; 352 goto close; 353 } 354 355 seq_write(m, resp.frd.data, resp.frd.readlen); 356 remaining -= resp.frd.readlen; 357 } 358 359 close: 360 close_err = mrq_debug_close(bpmp, fd); 361 if (!err) 362 err = close_err; 363 out: 364 mutex_unlock(&bpmp_debug_lock); 365 return err; 366 } 367 368 static ssize_t bpmp_debug_store(struct file *file, const char __user *buf, 369 size_t count, loff_t *f_pos) 370 { 371 struct inode *inode = file_inode(file); 372 struct tegra_bpmp *bpmp = inode->i_private; 373 char *databuf = NULL; 374 char fnamebuf[256]; 375 const char *filename; 376 ssize_t err; 377 378 filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf)); 379 if (!filename) 380 return -ENOENT; 381 382 databuf = memdup_user(buf, count); 383 if (IS_ERR(databuf)) 384 return PTR_ERR(databuf); 385 386 err = mrq_debug_write(bpmp, filename, databuf, count); 387 kfree(databuf); 388 389 return err ?: count; 390 } 391 392 static int bpmp_debug_open(struct inode *inode, struct file *file) 393 { 394 return single_open_size(file, bpmp_debug_show, file, SZ_256K); 395 } 396 397 static const struct file_operations bpmp_debug_fops = { 398 .open = bpmp_debug_open, 399 .read = seq_read, 400 .llseek = seq_lseek, 401 .write = bpmp_debug_store, 402 .release = single_release, 403 }; 404 405 static int bpmp_populate_debugfs_inband(struct tegra_bpmp *bpmp, 406 struct dentry *parent, 407 char *ppath) 408 { 409 const size_t pathlen = SZ_256; 410 const size_t bufsize = SZ_16K; 411 struct dentry *dentry; 412 u32 dsize, attrs = 0; 413 struct seqbuf seqbuf; 414 char *buf, *pathbuf; 415 const char *name; 416 int err = 0; 417 418 if (!bpmp || !parent || !ppath) 419 return -EINVAL; 420 421 buf = kmalloc(bufsize, GFP_KERNEL); 422 if (!buf) 423 return -ENOMEM; 424 425 pathbuf = kzalloc(pathlen, GFP_KERNEL); 426 if (!pathbuf) { 427 kfree(buf); 428 return -ENOMEM; 429 } 430 431 err = mrq_debug_read(bpmp, ppath, buf, bufsize, &dsize); 432 if (err) 433 goto out; 434 435 seqbuf_init(&seqbuf, buf, dsize); 436 437 while (!seqbuf_eof(&seqbuf)) { 438 err = seqbuf_read_u32(&seqbuf, &attrs); 439 if (err) 440 goto out; 441 442 err = seqbuf_read_str(&seqbuf, &name); 443 if (err < 0) 444 goto out; 445 446 if (attrs & DEBUGFS_S_ISDIR) { 447 size_t len; 448 449 dentry = debugfs_create_dir(name, parent); 450 if (IS_ERR(dentry)) { 451 err = PTR_ERR(dentry); 452 goto out; 453 } 454 455 len = snprintf(pathbuf, pathlen, "%s%s/", ppath, name); 456 if (len >= pathlen) { 457 err = -EINVAL; 458 goto out; 459 } 460 461 err = bpmp_populate_debugfs_inband(bpmp, dentry, 462 pathbuf); 463 if (err < 0) 464 goto out; 465 } else { 466 umode_t mode; 467 468 mode = attrs & DEBUGFS_S_IRUSR ? 0400 : 0; 469 mode |= attrs & DEBUGFS_S_IWUSR ? 0200 : 0; 470 dentry = debugfs_create_file(name, mode, parent, bpmp, 471 &bpmp_debug_fops); 472 if (IS_ERR(dentry)) { 473 err = PTR_ERR(dentry); 474 goto out; 475 } 476 } 477 } 478 479 out: 480 kfree(pathbuf); 481 kfree(buf); 482 483 return err; 484 } 485 486 static int mrq_debugfs_read(struct tegra_bpmp *bpmp, 487 dma_addr_t name, size_t sz_name, 488 dma_addr_t data, size_t sz_data, 489 size_t *nbytes) 490 { 491 struct mrq_debugfs_request req = { 492 .cmd = CMD_DEBUGFS_READ, 493 .fop = { 494 .fnameaddr = (u32)name, 495 .fnamelen = (u32)sz_name, 496 .dataaddr = (u32)data, 497 .datalen = (u32)sz_data, 498 }, 499 }; 500 struct mrq_debugfs_response resp; 501 struct tegra_bpmp_message msg = { 502 .mrq = MRQ_DEBUGFS, 503 .tx = { 504 .data = &req, 505 .size = sizeof(req), 506 }, 507 .rx = { 508 .data = &resp, 509 .size = sizeof(resp), 510 }, 511 }; 512 int err; 513 514 err = tegra_bpmp_transfer(bpmp, &msg); 515 if (err < 0) 516 return err; 517 else if (msg.rx.ret < 0) 518 return -EINVAL; 519 520 *nbytes = (size_t)resp.fop.nbytes; 521 522 return 0; 523 } 524 525 static int mrq_debugfs_write(struct tegra_bpmp *bpmp, 526 dma_addr_t name, size_t sz_name, 527 dma_addr_t data, size_t sz_data) 528 { 529 const struct mrq_debugfs_request req = { 530 .cmd = CMD_DEBUGFS_WRITE, 531 .fop = { 532 .fnameaddr = (u32)name, 533 .fnamelen = (u32)sz_name, 534 .dataaddr = (u32)data, 535 .datalen = (u32)sz_data, 536 }, 537 }; 538 struct tegra_bpmp_message msg = { 539 .mrq = MRQ_DEBUGFS, 540 .tx = { 541 .data = &req, 542 .size = sizeof(req), 543 }, 544 }; 545 546 return tegra_bpmp_transfer(bpmp, &msg); 547 } 548 549 static int mrq_debugfs_dumpdir(struct tegra_bpmp *bpmp, dma_addr_t addr, 550 size_t size, size_t *nbytes) 551 { 552 const struct mrq_debugfs_request req = { 553 .cmd = CMD_DEBUGFS_DUMPDIR, 554 .dumpdir = { 555 .dataaddr = (u32)addr, 556 .datalen = (u32)size, 557 }, 558 }; 559 struct mrq_debugfs_response resp; 560 struct tegra_bpmp_message msg = { 561 .mrq = MRQ_DEBUGFS, 562 .tx = { 563 .data = &req, 564 .size = sizeof(req), 565 }, 566 .rx = { 567 .data = &resp, 568 .size = sizeof(resp), 569 }, 570 }; 571 int err; 572 573 err = tegra_bpmp_transfer(bpmp, &msg); 574 if (err < 0) 575 return err; 576 else if (msg.rx.ret < 0) 577 return -EINVAL; 578 579 *nbytes = (size_t)resp.dumpdir.nbytes; 580 581 return 0; 582 } 583 584 static int debugfs_show(struct seq_file *m, void *p) 585 { 586 struct file *file = m->private; 587 struct inode *inode = file_inode(file); 588 struct tegra_bpmp *bpmp = inode->i_private; 589 const size_t datasize = m->size; 590 const size_t namesize = SZ_256; 591 void *datavirt, *namevirt; 592 dma_addr_t dataphys, namephys; 593 char buf[256]; 594 const char *filename; 595 size_t len, nbytes; 596 int err; 597 598 filename = get_filename(bpmp, file, buf, sizeof(buf)); 599 if (!filename) 600 return -ENOENT; 601 602 namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys, 603 GFP_KERNEL | GFP_DMA32); 604 if (!namevirt) 605 return -ENOMEM; 606 607 datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys, 608 GFP_KERNEL | GFP_DMA32); 609 if (!datavirt) { 610 err = -ENOMEM; 611 goto free_namebuf; 612 } 613 614 len = strlen(filename); 615 strscpy_pad(namevirt, filename, namesize); 616 617 err = mrq_debugfs_read(bpmp, namephys, len, dataphys, datasize, 618 &nbytes); 619 620 if (!err) 621 seq_write(m, datavirt, nbytes); 622 623 dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys); 624 free_namebuf: 625 dma_free_coherent(bpmp->dev, namesize, namevirt, namephys); 626 627 return err; 628 } 629 630 static int debugfs_open(struct inode *inode, struct file *file) 631 { 632 return single_open_size(file, debugfs_show, file, SZ_128K); 633 } 634 635 static ssize_t debugfs_store(struct file *file, const char __user *buf, 636 size_t count, loff_t *f_pos) 637 { 638 struct inode *inode = file_inode(file); 639 struct tegra_bpmp *bpmp = inode->i_private; 640 const size_t datasize = count; 641 const size_t namesize = SZ_256; 642 void *datavirt, *namevirt; 643 dma_addr_t dataphys, namephys; 644 char fnamebuf[256]; 645 const char *filename; 646 size_t len; 647 int err; 648 649 filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf)); 650 if (!filename) 651 return -ENOENT; 652 653 namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys, 654 GFP_KERNEL | GFP_DMA32); 655 if (!namevirt) 656 return -ENOMEM; 657 658 datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys, 659 GFP_KERNEL | GFP_DMA32); 660 if (!datavirt) { 661 err = -ENOMEM; 662 goto free_namebuf; 663 } 664 665 len = strlen(filename); 666 strscpy_pad(namevirt, filename, namesize); 667 668 if (copy_from_user(datavirt, buf, count)) { 669 err = -EFAULT; 670 goto free_databuf; 671 } 672 673 err = mrq_debugfs_write(bpmp, namephys, len, dataphys, 674 count); 675 676 free_databuf: 677 dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys); 678 free_namebuf: 679 dma_free_coherent(bpmp->dev, namesize, namevirt, namephys); 680 681 return err ?: count; 682 } 683 684 static const struct file_operations debugfs_fops = { 685 .open = debugfs_open, 686 .read = seq_read, 687 .llseek = seq_lseek, 688 .write = debugfs_store, 689 .release = single_release, 690 }; 691 692 static int bpmp_populate_dir(struct tegra_bpmp *bpmp, struct seqbuf *seqbuf, 693 struct dentry *parent, u32 depth) 694 { 695 int err; 696 u32 d, t; 697 const char *name; 698 struct dentry *dentry; 699 700 while (!seqbuf_eof(seqbuf)) { 701 err = seqbuf_read_u32(seqbuf, &d); 702 if (err < 0) 703 return err; 704 705 if (d < depth) { 706 seqbuf_seek(seqbuf, -4); 707 /* go up a level */ 708 return 0; 709 } else if (d != depth) { 710 /* malformed data received from BPMP */ 711 return -EIO; 712 } 713 714 err = seqbuf_read_u32(seqbuf, &t); 715 if (err < 0) 716 return err; 717 err = seqbuf_read_str(seqbuf, &name); 718 if (err < 0) 719 return err; 720 721 if (t & DEBUGFS_S_ISDIR) { 722 dentry = debugfs_create_dir(name, parent); 723 if (IS_ERR(dentry)) 724 return PTR_ERR(dentry); 725 err = bpmp_populate_dir(bpmp, seqbuf, dentry, depth+1); 726 if (err < 0) 727 return err; 728 } else { 729 umode_t mode; 730 731 mode = t & DEBUGFS_S_IRUSR ? S_IRUSR : 0; 732 mode |= t & DEBUGFS_S_IWUSR ? S_IWUSR : 0; 733 dentry = debugfs_create_file(name, mode, 734 parent, bpmp, 735 &debugfs_fops); 736 if (IS_ERR(dentry)) 737 return PTR_ERR(dentry); 738 } 739 } 740 741 return 0; 742 } 743 744 static int bpmp_populate_debugfs_shmem(struct tegra_bpmp *bpmp) 745 { 746 struct seqbuf seqbuf; 747 const size_t sz = SZ_512K; 748 dma_addr_t phys; 749 size_t nbytes; 750 void *virt; 751 int err; 752 753 virt = dma_alloc_coherent(bpmp->dev, sz, &phys, 754 GFP_KERNEL | GFP_DMA32); 755 if (!virt) 756 return -ENOMEM; 757 758 err = mrq_debugfs_dumpdir(bpmp, phys, sz, &nbytes); 759 if (err < 0) { 760 goto free; 761 } else if (nbytes > sz) { 762 err = -EINVAL; 763 goto free; 764 } 765 766 seqbuf_init(&seqbuf, virt, nbytes); 767 err = bpmp_populate_dir(bpmp, &seqbuf, bpmp->debugfs_mirror, 0); 768 free: 769 dma_free_coherent(bpmp->dev, sz, virt, phys); 770 771 return err; 772 } 773 774 static DEFINE_MUTEX(bpmp_debugfs_root_lock); 775 static struct dentry *bpmp_debugfs_root; 776 777 static struct dentry *bpmp_debugfs_get_root(void) 778 { 779 guard(mutex)(&bpmp_debugfs_root_lock); 780 if (!bpmp_debugfs_root) 781 bpmp_debugfs_root = debugfs_create_dir("bpmp", NULL); 782 return bpmp_debugfs_root; 783 } 784 785 int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp) 786 { 787 struct dentry *root, *d; 788 char name[32]; 789 bool inband; 790 int err; 791 792 inband = tegra_bpmp_mrq_is_supported(bpmp, MRQ_DEBUG); 793 794 if (!inband && !tegra_bpmp_mrq_is_supported(bpmp, MRQ_DEBUGFS)) 795 return 0; 796 797 root = bpmp_debugfs_get_root(); 798 if (IS_ERR(root)) 799 return PTR_ERR(root); 800 801 if (dev_to_node(bpmp->dev) == NUMA_NO_NODE) { 802 d = root; 803 } else { 804 snprintf(name, sizeof(name), "%d-bpmp", dev_to_node(bpmp->dev)); 805 d = debugfs_create_dir(name, root); 806 if (IS_ERR(d)) { 807 err = PTR_ERR(d); 808 goto out; 809 } 810 } 811 812 bpmp->debugfs_mirror = debugfs_create_dir("debug", d); 813 if (IS_ERR(bpmp->debugfs_mirror)) { 814 err = PTR_ERR(bpmp->debugfs_mirror); 815 goto out; 816 } 817 818 if (inband) 819 err = bpmp_populate_debugfs_inband(bpmp, bpmp->debugfs_mirror, 820 "/"); 821 else 822 err = bpmp_populate_debugfs_shmem(bpmp); 823 824 out: 825 if (err < 0) { 826 if (!IS_ERR(d)) 827 debugfs_remove_recursive(d); 828 829 guard(mutex)(&bpmp_debugfs_root_lock); 830 if (root == d) { 831 bpmp_debugfs_root = NULL; 832 } else if (simple_empty(root)) { 833 debugfs_remove(root); 834 bpmp_debugfs_root = NULL; 835 } 836 } 837 838 return err; 839 } 840