blktrace.c (7bed14551659875e1cd23a7c0266394a29a773b3) blktrace.c (f3bdc62fd82ed93dbe4d049eacba310de7eb2a6a)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2006 Jens Axboe <axboe@kernel.dk>
4 *
5 */
6
7#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8

--- 334 unchanged lines hidden (view full) ---

343 put_probe_ref();
344}
345
346static int __blk_trace_remove(struct request_queue *q)
347{
348 struct blk_trace *bt;
349
350 bt = rcu_replace_pointer(q->blk_trace, NULL,
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2006 Jens Axboe <axboe@kernel.dk>
4 *
5 */
6
7#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8

--- 334 unchanged lines hidden (view full) ---

343 put_probe_ref();
344}
345
346static int __blk_trace_remove(struct request_queue *q)
347{
348 struct blk_trace *bt;
349
350 bt = rcu_replace_pointer(q->blk_trace, NULL,
351 lockdep_is_held(&q->blk_trace_mutex));
351 lockdep_is_held(&q->debugfs_mutex));
352 if (!bt)
353 return -EINVAL;
354
355 if (bt->trace_state != Blktrace_running)
356 blk_trace_cleanup(bt);
357
358 return 0;
359}
360
361int blk_trace_remove(struct request_queue *q)
362{
363 int ret;
364
352 if (!bt)
353 return -EINVAL;
354
355 if (bt->trace_state != Blktrace_running)
356 blk_trace_cleanup(bt);
357
358 return 0;
359}
360
361int blk_trace_remove(struct request_queue *q)
362{
363 int ret;
364
365 mutex_lock(&q->blk_trace_mutex);
365 mutex_lock(&q->debugfs_mutex);
366 ret = __blk_trace_remove(q);
366 ret = __blk_trace_remove(q);
367 mutex_unlock(&q->blk_trace_mutex);
367 mutex_unlock(&q->debugfs_mutex);
368
369 return ret;
370}
371EXPORT_SYMBOL_GPL(blk_trace_remove);
372
373static ssize_t blk_dropped_read(struct file *filp, char __user *buffer,
374 size_t count, loff_t *ppos)
375{

--- 102 unchanged lines hidden (view full) ---

478static int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
479 struct block_device *bdev,
480 struct blk_user_trace_setup *buts)
481{
482 struct blk_trace *bt = NULL;
483 struct dentry *dir = NULL;
484 int ret;
485
368
369 return ret;
370}
371EXPORT_SYMBOL_GPL(blk_trace_remove);
372
373static ssize_t blk_dropped_read(struct file *filp, char __user *buffer,
374 size_t count, loff_t *ppos)
375{

--- 102 unchanged lines hidden (view full) ---

478static int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
479 struct block_device *bdev,
480 struct blk_user_trace_setup *buts)
481{
482 struct blk_trace *bt = NULL;
483 struct dentry *dir = NULL;
484 int ret;
485
486 lockdep_assert_held(&q->debugfs_mutex);
487
486 if (!buts->buf_size || !buts->buf_nr)
487 return -EINVAL;
488
488 if (!buts->buf_size || !buts->buf_nr)
489 return -EINVAL;
490
489 if (!blk_debugfs_root)
490 return -ENOENT;
491
492 strncpy(buts->name, name, BLKTRACE_BDEV_SIZE);
493 buts->name[BLKTRACE_BDEV_SIZE - 1] = '\0';
494
495 /*
496 * some device names have larger paths - convert the slashes
497 * to underscores for this to work as expected
498 */
499 strreplace(buts->name, '/', '_');
500
501 /*
502 * bdev can be NULL, as with scsi-generic, this is a helpful as
503 * we can be.
504 */
505 if (rcu_dereference_protected(q->blk_trace,
491 strncpy(buts->name, name, BLKTRACE_BDEV_SIZE);
492 buts->name[BLKTRACE_BDEV_SIZE - 1] = '\0';
493
494 /*
495 * some device names have larger paths - convert the slashes
496 * to underscores for this to work as expected
497 */
498 strreplace(buts->name, '/', '_');
499
500 /*
501 * bdev can be NULL, as with scsi-generic, this is a helpful as
502 * we can be.
503 */
504 if (rcu_dereference_protected(q->blk_trace,
506 lockdep_is_held(&q->blk_trace_mutex))) {
505 lockdep_is_held(&q->debugfs_mutex))) {
507 pr_warn("Concurrent blktraces are not allowed on %s\n",
508 buts->name);
509 return -EBUSY;
510 }
511
512 bt = kzalloc(sizeof(*bt), GFP_KERNEL);
513 if (!bt)
514 return -ENOMEM;
515
516 ret = -ENOMEM;
517 bt->sequence = alloc_percpu(unsigned long);
518 if (!bt->sequence)
519 goto err;
520
521 bt->msg_data = __alloc_percpu(BLK_TN_MAX_MSG, __alignof__(char));
522 if (!bt->msg_data)
523 goto err;
524
506 pr_warn("Concurrent blktraces are not allowed on %s\n",
507 buts->name);
508 return -EBUSY;
509 }
510
511 bt = kzalloc(sizeof(*bt), GFP_KERNEL);
512 if (!bt)
513 return -ENOMEM;
514
515 ret = -ENOMEM;
516 bt->sequence = alloc_percpu(unsigned long);
517 if (!bt->sequence)
518 goto err;
519
520 bt->msg_data = __alloc_percpu(BLK_TN_MAX_MSG, __alignof__(char));
521 if (!bt->msg_data)
522 goto err;
523
525 ret = -ENOENT;
526
527 dir = debugfs_lookup(buts->name, blk_debugfs_root);
528 if (!dir)
524 /*
525 * When tracing the whole disk reuse the existing debugfs directory
526 * created by the block layer on init. For partitions block devices,
527 * and scsi-generic block devices we create a temporary new debugfs
528 * directory that will be removed once the trace ends.
529 */
530 if (bdev && bdev == bdev->bd_contains)
531 dir = q->debugfs_dir;
532 else
529 bt->dir = dir = debugfs_create_dir(buts->name, blk_debugfs_root);
530
533 bt->dir = dir = debugfs_create_dir(buts->name, blk_debugfs_root);
534
535 /*
536 * As blktrace relies on debugfs for its interface the debugfs directory
537 * is required, contrary to the usual mantra of not checking for debugfs
538 * files or directories.
539 */
540 if (IS_ERR_OR_NULL(dir)) {
541 pr_warn("debugfs_dir not present for %s so skipping\n",
542 buts->name);
543 ret = -ENOENT;
544 goto err;
545 }
546
531 bt->dev = dev;
532 atomic_set(&bt->dropped, 0);
533 INIT_LIST_HEAD(&bt->running_list);
534
535 ret = -EIO;
536 bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt,
537 &blk_dropped_fops);
538

--- 19 unchanged lines hidden (view full) ---

558 bt->pid = buts->pid;
559 bt->trace_state = Blktrace_setup;
560
561 rcu_assign_pointer(q->blk_trace, bt);
562 get_probe_ref();
563
564 ret = 0;
565err:
547 bt->dev = dev;
548 atomic_set(&bt->dropped, 0);
549 INIT_LIST_HEAD(&bt->running_list);
550
551 ret = -EIO;
552 bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt,
553 &blk_dropped_fops);
554

--- 19 unchanged lines hidden (view full) ---

574 bt->pid = buts->pid;
575 bt->trace_state = Blktrace_setup;
576
577 rcu_assign_pointer(q->blk_trace, bt);
578 get_probe_ref();
579
580 ret = 0;
581err:
566 if (dir && !bt->dir)
567 dput(dir);
568 if (ret)
569 blk_trace_free(bt);
570 return ret;
571}
572
573static int __blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
574 struct block_device *bdev, char __user *arg)
575{

--- 16 unchanged lines hidden (view full) ---

592}
593
594int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
595 struct block_device *bdev,
596 char __user *arg)
597{
598 int ret;
599
582 if (ret)
583 blk_trace_free(bt);
584 return ret;
585}
586
587static int __blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
588 struct block_device *bdev, char __user *arg)
589{

--- 16 unchanged lines hidden (view full) ---

606}
607
608int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
609 struct block_device *bdev,
610 char __user *arg)
611{
612 int ret;
613
600 mutex_lock(&q->blk_trace_mutex);
614 mutex_lock(&q->debugfs_mutex);
601 ret = __blk_trace_setup(q, name, dev, bdev, arg);
615 ret = __blk_trace_setup(q, name, dev, bdev, arg);
602 mutex_unlock(&q->blk_trace_mutex);
616 mutex_unlock(&q->debugfs_mutex);
603
604 return ret;
605}
606EXPORT_SYMBOL_GPL(blk_trace_setup);
607
608#if defined(CONFIG_COMPAT) && defined(CONFIG_X86_64)
609static int compat_blk_trace_setup(struct request_queue *q, char *name,
610 dev_t dev, struct block_device *bdev,

--- 29 unchanged lines hidden (view full) ---

640#endif
641
642static int __blk_trace_startstop(struct request_queue *q, int start)
643{
644 int ret;
645 struct blk_trace *bt;
646
647 bt = rcu_dereference_protected(q->blk_trace,
617
618 return ret;
619}
620EXPORT_SYMBOL_GPL(blk_trace_setup);
621
622#if defined(CONFIG_COMPAT) && defined(CONFIG_X86_64)
623static int compat_blk_trace_setup(struct request_queue *q, char *name,
624 dev_t dev, struct block_device *bdev,

--- 29 unchanged lines hidden (view full) ---

654#endif
655
656static int __blk_trace_startstop(struct request_queue *q, int start)
657{
658 int ret;
659 struct blk_trace *bt;
660
661 bt = rcu_dereference_protected(q->blk_trace,
648 lockdep_is_held(&q->blk_trace_mutex));
662 lockdep_is_held(&q->debugfs_mutex));
649 if (bt == NULL)
650 return -EINVAL;
651
652 /*
653 * For starting a trace, we can transition from a setup or stopped
654 * trace. For stopping a trace, the state must be running
655 */
656 ret = -EINVAL;

--- 23 unchanged lines hidden (view full) ---

680
681 return ret;
682}
683
684int blk_trace_startstop(struct request_queue *q, int start)
685{
686 int ret;
687
663 if (bt == NULL)
664 return -EINVAL;
665
666 /*
667 * For starting a trace, we can transition from a setup or stopped
668 * trace. For stopping a trace, the state must be running
669 */
670 ret = -EINVAL;

--- 23 unchanged lines hidden (view full) ---

694
695 return ret;
696}
697
698int blk_trace_startstop(struct request_queue *q, int start)
699{
700 int ret;
701
688 mutex_lock(&q->blk_trace_mutex);
702 mutex_lock(&q->debugfs_mutex);
689 ret = __blk_trace_startstop(q, start);
703 ret = __blk_trace_startstop(q, start);
690 mutex_unlock(&q->blk_trace_mutex);
704 mutex_unlock(&q->debugfs_mutex);
691
692 return ret;
693}
694EXPORT_SYMBOL_GPL(blk_trace_startstop);
695
696/*
697 * When reading or writing the blktrace sysfs files, the references to the
698 * opened sysfs or device files should prevent the underlying block device

--- 12 unchanged lines hidden (view full) ---

711 struct request_queue *q;
712 int ret, start = 0;
713 char b[BDEVNAME_SIZE];
714
715 q = bdev_get_queue(bdev);
716 if (!q)
717 return -ENXIO;
718
705
706 return ret;
707}
708EXPORT_SYMBOL_GPL(blk_trace_startstop);
709
710/*
711 * When reading or writing the blktrace sysfs files, the references to the
712 * opened sysfs or device files should prevent the underlying block device

--- 12 unchanged lines hidden (view full) ---

725 struct request_queue *q;
726 int ret, start = 0;
727 char b[BDEVNAME_SIZE];
728
729 q = bdev_get_queue(bdev);
730 if (!q)
731 return -ENXIO;
732
719 mutex_lock(&q->blk_trace_mutex);
733 mutex_lock(&q->debugfs_mutex);
720
721 switch (cmd) {
722 case BLKTRACESETUP:
723 bdevname(bdev, b);
724 ret = __blk_trace_setup(q, b, bdev->bd_dev, bdev, arg);
725 break;
726#if defined(CONFIG_COMPAT) && defined(CONFIG_X86_64)
727 case BLKTRACESETUP32:

--- 10 unchanged lines hidden (view full) ---

738 case BLKTRACETEARDOWN:
739 ret = __blk_trace_remove(q);
740 break;
741 default:
742 ret = -ENOTTY;
743 break;
744 }
745
734
735 switch (cmd) {
736 case BLKTRACESETUP:
737 bdevname(bdev, b);
738 ret = __blk_trace_setup(q, b, bdev->bd_dev, bdev, arg);
739 break;
740#if defined(CONFIG_COMPAT) && defined(CONFIG_X86_64)
741 case BLKTRACESETUP32:

--- 10 unchanged lines hidden (view full) ---

752 case BLKTRACETEARDOWN:
753 ret = __blk_trace_remove(q);
754 break;
755 default:
756 ret = -ENOTTY;
757 break;
758 }
759
746 mutex_unlock(&q->blk_trace_mutex);
760 mutex_unlock(&q->debugfs_mutex);
747 return ret;
748}
749
750/**
751 * blk_trace_shutdown: - stop and cleanup trace structures
752 * @q: the request queue associated with the device
753 *
754 **/
755void blk_trace_shutdown(struct request_queue *q)
756{
761 return ret;
762}
763
764/**
765 * blk_trace_shutdown: - stop and cleanup trace structures
766 * @q: the request queue associated with the device
767 *
768 **/
769void blk_trace_shutdown(struct request_queue *q)
770{
757 mutex_lock(&q->blk_trace_mutex);
771 mutex_lock(&q->debugfs_mutex);
758 if (rcu_dereference_protected(q->blk_trace,
772 if (rcu_dereference_protected(q->blk_trace,
759 lockdep_is_held(&q->blk_trace_mutex))) {
773 lockdep_is_held(&q->debugfs_mutex))) {
760 __blk_trace_startstop(q, 0);
761 __blk_trace_remove(q);
762 }
763
774 __blk_trace_startstop(q, 0);
775 __blk_trace_remove(q);
776 }
777
764 mutex_unlock(&q->blk_trace_mutex);
778 mutex_unlock(&q->debugfs_mutex);
765}
766
767#ifdef CONFIG_BLK_CGROUP
768static u64 blk_trace_bio_get_cgid(struct request_queue *q, struct bio *bio)
769{
770 struct blk_trace *bt;
771
772 /* We don't use the 'bt' value here except as an optimization... */

--- 68 unchanged lines hidden (view full) ---

841
842static void blk_add_trace_rq_issue(void *ignore,
843 struct request_queue *q, struct request *rq)
844{
845 blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_ISSUE,
846 blk_trace_request_get_cgid(q, rq));
847}
848
779}
780
781#ifdef CONFIG_BLK_CGROUP
782static u64 blk_trace_bio_get_cgid(struct request_queue *q, struct bio *bio)
783{
784 struct blk_trace *bt;
785
786 /* We don't use the 'bt' value here except as an optimization... */

--- 68 unchanged lines hidden (view full) ---

855
856static void blk_add_trace_rq_issue(void *ignore,
857 struct request_queue *q, struct request *rq)
858{
859 blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_ISSUE,
860 blk_trace_request_get_cgid(q, rq));
861}
862
863static void blk_add_trace_rq_merge(void *ignore,
864 struct request_queue *q, struct request *rq)
865{
866 blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_BACKMERGE,
867 blk_trace_request_get_cgid(q, rq));
868}
869
849static void blk_add_trace_rq_requeue(void *ignore,
850 struct request_queue *q,
851 struct request *rq)
852{
853 blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_REQUEUE,
854 blk_trace_request_get_cgid(q, rq));
855}
856

--- 268 unchanged lines hidden (view full) ---

1125static void blk_register_tracepoints(void)
1126{
1127 int ret;
1128
1129 ret = register_trace_block_rq_insert(blk_add_trace_rq_insert, NULL);
1130 WARN_ON(ret);
1131 ret = register_trace_block_rq_issue(blk_add_trace_rq_issue, NULL);
1132 WARN_ON(ret);
870static void blk_add_trace_rq_requeue(void *ignore,
871 struct request_queue *q,
872 struct request *rq)
873{
874 blk_add_trace_rq(rq, 0, blk_rq_bytes(rq), BLK_TA_REQUEUE,
875 blk_trace_request_get_cgid(q, rq));
876}
877

--- 268 unchanged lines hidden (view full) ---

1146static void blk_register_tracepoints(void)
1147{
1148 int ret;
1149
1150 ret = register_trace_block_rq_insert(blk_add_trace_rq_insert, NULL);
1151 WARN_ON(ret);
1152 ret = register_trace_block_rq_issue(blk_add_trace_rq_issue, NULL);
1153 WARN_ON(ret);
1154 ret = register_trace_block_rq_merge(blk_add_trace_rq_merge, NULL);
1155 WARN_ON(ret);
1133 ret = register_trace_block_rq_requeue(blk_add_trace_rq_requeue, NULL);
1134 WARN_ON(ret);
1135 ret = register_trace_block_rq_complete(blk_add_trace_rq_complete, NULL);
1136 WARN_ON(ret);
1137 ret = register_trace_block_bio_bounce(blk_add_trace_bio_bounce, NULL);
1138 WARN_ON(ret);
1139 ret = register_trace_block_bio_complete(blk_add_trace_bio_complete, NULL);
1140 WARN_ON(ret);

--- 30 unchanged lines hidden (view full) ---

1171 unregister_trace_block_getrq(blk_add_trace_getrq, NULL);
1172 unregister_trace_block_bio_queue(blk_add_trace_bio_queue, NULL);
1173 unregister_trace_block_bio_frontmerge(blk_add_trace_bio_frontmerge, NULL);
1174 unregister_trace_block_bio_backmerge(blk_add_trace_bio_backmerge, NULL);
1175 unregister_trace_block_bio_complete(blk_add_trace_bio_complete, NULL);
1176 unregister_trace_block_bio_bounce(blk_add_trace_bio_bounce, NULL);
1177 unregister_trace_block_rq_complete(blk_add_trace_rq_complete, NULL);
1178 unregister_trace_block_rq_requeue(blk_add_trace_rq_requeue, NULL);
1156 ret = register_trace_block_rq_requeue(blk_add_trace_rq_requeue, NULL);
1157 WARN_ON(ret);
1158 ret = register_trace_block_rq_complete(blk_add_trace_rq_complete, NULL);
1159 WARN_ON(ret);
1160 ret = register_trace_block_bio_bounce(blk_add_trace_bio_bounce, NULL);
1161 WARN_ON(ret);
1162 ret = register_trace_block_bio_complete(blk_add_trace_bio_complete, NULL);
1163 WARN_ON(ret);

--- 30 unchanged lines hidden (view full) ---

1194 unregister_trace_block_getrq(blk_add_trace_getrq, NULL);
1195 unregister_trace_block_bio_queue(blk_add_trace_bio_queue, NULL);
1196 unregister_trace_block_bio_frontmerge(blk_add_trace_bio_frontmerge, NULL);
1197 unregister_trace_block_bio_backmerge(blk_add_trace_bio_backmerge, NULL);
1198 unregister_trace_block_bio_complete(blk_add_trace_bio_complete, NULL);
1199 unregister_trace_block_bio_bounce(blk_add_trace_bio_bounce, NULL);
1200 unregister_trace_block_rq_complete(blk_add_trace_rq_complete, NULL);
1201 unregister_trace_block_rq_requeue(blk_add_trace_rq_requeue, NULL);
1202 unregister_trace_block_rq_merge(blk_add_trace_rq_merge, NULL);
1179 unregister_trace_block_rq_issue(blk_add_trace_rq_issue, NULL);
1180 unregister_trace_block_rq_insert(blk_add_trace_rq_insert, NULL);
1181
1182 tracepoint_synchronize_unregister();
1183}
1184
1185/*
1186 * struct blk_io_tracer formatting routines

--- 450 unchanged lines hidden (view full) ---

1637
1638device_initcall(init_blk_tracer);
1639
1640static int blk_trace_remove_queue(struct request_queue *q)
1641{
1642 struct blk_trace *bt;
1643
1644 bt = rcu_replace_pointer(q->blk_trace, NULL,
1203 unregister_trace_block_rq_issue(blk_add_trace_rq_issue, NULL);
1204 unregister_trace_block_rq_insert(blk_add_trace_rq_insert, NULL);
1205
1206 tracepoint_synchronize_unregister();
1207}
1208
1209/*
1210 * struct blk_io_tracer formatting routines

--- 450 unchanged lines hidden (view full) ---

1661
1662device_initcall(init_blk_tracer);
1663
1664static int blk_trace_remove_queue(struct request_queue *q)
1665{
1666 struct blk_trace *bt;
1667
1668 bt = rcu_replace_pointer(q->blk_trace, NULL,
1645 lockdep_is_held(&q->blk_trace_mutex));
1669 lockdep_is_held(&q->debugfs_mutex));
1646 if (bt == NULL)
1647 return -EINVAL;
1648
1649 put_probe_ref();
1650 synchronize_rcu();
1651 blk_trace_free(bt);
1652 return 0;
1653}

--- 158 unchanged lines hidden (view full) ---

1812 bdev = bdget(part_devt(p));
1813 if (bdev == NULL)
1814 goto out;
1815
1816 q = blk_trace_get_queue(bdev);
1817 if (q == NULL)
1818 goto out_bdput;
1819
1670 if (bt == NULL)
1671 return -EINVAL;
1672
1673 put_probe_ref();
1674 synchronize_rcu();
1675 blk_trace_free(bt);
1676 return 0;
1677}

--- 158 unchanged lines hidden (view full) ---

1836 bdev = bdget(part_devt(p));
1837 if (bdev == NULL)
1838 goto out;
1839
1840 q = blk_trace_get_queue(bdev);
1841 if (q == NULL)
1842 goto out_bdput;
1843
1820 mutex_lock(&q->blk_trace_mutex);
1844 mutex_lock(&q->debugfs_mutex);
1821
1822 bt = rcu_dereference_protected(q->blk_trace,
1845
1846 bt = rcu_dereference_protected(q->blk_trace,
1823 lockdep_is_held(&q->blk_trace_mutex));
1847 lockdep_is_held(&q->debugfs_mutex));
1824 if (attr == &dev_attr_enable) {
1825 ret = sprintf(buf, "%u\n", !!bt);
1826 goto out_unlock_bdev;
1827 }
1828
1829 if (bt == NULL)
1830 ret = sprintf(buf, "disabled\n");
1831 else if (attr == &dev_attr_act_mask)
1832 ret = blk_trace_mask2str(buf, bt->act_mask);
1833 else if (attr == &dev_attr_pid)
1834 ret = sprintf(buf, "%u\n", bt->pid);
1835 else if (attr == &dev_attr_start_lba)
1836 ret = sprintf(buf, "%llu\n", bt->start_lba);
1837 else if (attr == &dev_attr_end_lba)
1838 ret = sprintf(buf, "%llu\n", bt->end_lba);
1839
1840out_unlock_bdev:
1848 if (attr == &dev_attr_enable) {
1849 ret = sprintf(buf, "%u\n", !!bt);
1850 goto out_unlock_bdev;
1851 }
1852
1853 if (bt == NULL)
1854 ret = sprintf(buf, "disabled\n");
1855 else if (attr == &dev_attr_act_mask)
1856 ret = blk_trace_mask2str(buf, bt->act_mask);
1857 else if (attr == &dev_attr_pid)
1858 ret = sprintf(buf, "%u\n", bt->pid);
1859 else if (attr == &dev_attr_start_lba)
1860 ret = sprintf(buf, "%llu\n", bt->start_lba);
1861 else if (attr == &dev_attr_end_lba)
1862 ret = sprintf(buf, "%llu\n", bt->end_lba);
1863
1864out_unlock_bdev:
1841 mutex_unlock(&q->blk_trace_mutex);
1865 mutex_unlock(&q->debugfs_mutex);
1842out_bdput:
1843 bdput(bdev);
1844out:
1845 return ret;
1846}
1847
1848static ssize_t sysfs_blk_trace_attr_store(struct device *dev,
1849 struct device_attribute *attr,

--- 26 unchanged lines hidden (view full) ---

1876 bdev = bdget(part_devt(p));
1877 if (bdev == NULL)
1878 goto out;
1879
1880 q = blk_trace_get_queue(bdev);
1881 if (q == NULL)
1882 goto out_bdput;
1883
1866out_bdput:
1867 bdput(bdev);
1868out:
1869 return ret;
1870}
1871
1872static ssize_t sysfs_blk_trace_attr_store(struct device *dev,
1873 struct device_attribute *attr,

--- 26 unchanged lines hidden (view full) ---

1900 bdev = bdget(part_devt(p));
1901 if (bdev == NULL)
1902 goto out;
1903
1904 q = blk_trace_get_queue(bdev);
1905 if (q == NULL)
1906 goto out_bdput;
1907
1884 mutex_lock(&q->blk_trace_mutex);
1908 mutex_lock(&q->debugfs_mutex);
1885
1886 bt = rcu_dereference_protected(q->blk_trace,
1909
1910 bt = rcu_dereference_protected(q->blk_trace,
1887 lockdep_is_held(&q->blk_trace_mutex));
1911 lockdep_is_held(&q->debugfs_mutex));
1888 if (attr == &dev_attr_enable) {
1889 if (!!value == !!bt) {
1890 ret = 0;
1891 goto out_unlock_bdev;
1892 }
1893 if (value)
1894 ret = blk_trace_setup_queue(q, bdev);
1895 else
1896 ret = blk_trace_remove_queue(q);
1897 goto out_unlock_bdev;
1898 }
1899
1900 ret = 0;
1901 if (bt == NULL) {
1902 ret = blk_trace_setup_queue(q, bdev);
1903 bt = rcu_dereference_protected(q->blk_trace,
1912 if (attr == &dev_attr_enable) {
1913 if (!!value == !!bt) {
1914 ret = 0;
1915 goto out_unlock_bdev;
1916 }
1917 if (value)
1918 ret = blk_trace_setup_queue(q, bdev);
1919 else
1920 ret = blk_trace_remove_queue(q);
1921 goto out_unlock_bdev;
1922 }
1923
1924 ret = 0;
1925 if (bt == NULL) {
1926 ret = blk_trace_setup_queue(q, bdev);
1927 bt = rcu_dereference_protected(q->blk_trace,
1904 lockdep_is_held(&q->blk_trace_mutex));
1928 lockdep_is_held(&q->debugfs_mutex));
1905 }
1906
1907 if (ret == 0) {
1908 if (attr == &dev_attr_act_mask)
1909 bt->act_mask = value;
1910 else if (attr == &dev_attr_pid)
1911 bt->pid = value;
1912 else if (attr == &dev_attr_start_lba)
1913 bt->start_lba = value;
1914 else if (attr == &dev_attr_end_lba)
1915 bt->end_lba = value;
1916 }
1917
1918out_unlock_bdev:
1929 }
1930
1931 if (ret == 0) {
1932 if (attr == &dev_attr_act_mask)
1933 bt->act_mask = value;
1934 else if (attr == &dev_attr_pid)
1935 bt->pid = value;
1936 else if (attr == &dev_attr_start_lba)
1937 bt->start_lba = value;
1938 else if (attr == &dev_attr_end_lba)
1939 bt->end_lba = value;
1940 }
1941
1942out_unlock_bdev:
1919 mutex_unlock(&q->blk_trace_mutex);
1943 mutex_unlock(&q->debugfs_mutex);
1920out_bdput:
1921 bdput(bdev);
1922out:
1923 return ret ? ret : count;
1924}
1925
1926int blk_trace_init_sysfs(struct device *dev)
1927{

--- 56 unchanged lines hidden --- 		1944out_bdput:
1945 bdput(bdev);
1946out:
1947 return ret ? ret : count;
1948}
1949
1950int blk_trace_init_sysfs(struct device *dev)
1951{

--- 56 unchanged lines hidden ---