#!/usr/bin/perl -w # (c) 2009, Tom Zanussi # Licensed under the terms of the GNU GPL License version 2 # Display r/w activity for all processes # The common_* event handler fields are the most useful fields common to # all events. They don't necessarily correspond to the 'common_*' fields # in the status files. Those fields not available as handler params can # be retrieved via script functions of the form get_common_*(). use 5.010000; use strict; use warnings; use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib"; use lib "./Perf-Trace-Util/lib"; use Perf::Trace::Core; use Perf::Trace::Util; my %reads; my %writes; sub syscalls::sys_exit_read { my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs, $common_pid, $common_comm, $nr, $ret) = @_; if ($ret > 0) { $reads{$common_pid}{bytes_read} += $ret; } else { if (!defined ($reads{$common_pid}{bytes_read})) { $reads{$common_pid}{bytes_read} = 0; } $reads{$common_pid}{errors}{$ret}++; } } sub syscalls::sys_enter_read { my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs, $common_pid, $common_comm, $nr, $fd, $buf, $count) = @_; $reads{$common_pid}{bytes_requested} += $count; $reads{$common_pid}{total_reads}++; $reads{$common_pid}{comm} = $common_comm; } sub syscalls::sys_exit_write { my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs, $common_pid, $common_comm, $nr, $ret) = @_; if ($ret <= 0) { $writes{$common_pid}{errors}{$ret}++; } } sub syscalls::sys_enter_write { my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs, $common_pid, $common_comm, $nr, $fd, $buf, $count) = @_; $writes{$common_pid}{bytes_written} += $count; $writes{$common_pid}{total_writes}++; $writes{$common_pid}{comm} = $common_comm; } sub trace_end { printf("read counts by pid:\n\n"); printf("%6s %20s %10s %10s %10s\n", "pid", "comm", "# reads", "bytes_requested", "bytes_read"); printf("%6s %-20s %10s %10s %10s\n", "------", "--------------------", "-----------", "----------", "----------"); foreach my $pid (sort { ($reads{$b}{bytes_read} || 0) <=> ($reads{$a}{bytes_read} || 0) } keys %reads) { my $comm = $reads{$pid}{comm} || ""; my $total_reads = $reads{$pid}{total_reads} || 0; my $bytes_requested = $reads{$pid}{bytes_requested} || 0; my $bytes_read = $reads{$pid}{bytes_read} || 0; printf("%6s %-20s %10s %10s %10s\n", $pid, $comm, $total_reads, $bytes_requested, $bytes_read); } printf("\nfailed reads by pid:\n\n"); printf("%6s %20s %6s %10s\n", "pid", "comm", "error #", "# errors"); printf("%6s %20s %6s %10s\n", "------", "--------------------", "------", "----------"); my @errcounts = (); foreach my $pid (keys %reads) { foreach my $error (keys %{$reads{$pid}{errors}}) { my $comm = $reads{$pid}{comm} || ""; my $errcount = $reads{$pid}{errors}{$error} || 0; push @errcounts, [$pid, $comm, $error, $errcount]; } } @errcounts = sort { $b->[3] <=> $a->[3] } @errcounts; for my $i (0 .. $#errcounts) { printf("%6d %-20s %6d %10s\n", $errcounts[$i][0], $errcounts[$i][1], $errcounts[$i][2], $errcounts[$i][3]); } printf("\nwrite counts by pid:\n\n"); printf("%6s %20s %10s %10s\n", "pid", "comm", "# writes", "bytes_written"); printf("%6s %-20s %10s %10s\n", "------", "--------------------", "-----------", "----------"); foreach my $pid (sort { ($writes{$b}{bytes_written} || 0) <=> ($writes{$a}{bytes_written} || 0)} keys %writes) { my $comm = $writes{$pid}{comm} || ""; my $total_writes = $writes{$pid}{total_writes} || 0; my $bytes_written = $writes{$pid}{bytes_written} || 0; printf("%6s %-20s %10s %10s\n", $pid, $comm, $total_writes, $bytes_written); } printf("\nfailed writes by pid:\n\n"); printf("%6s %20s %6s %10s\n", "pid", "comm", "error #", "# errors"); printf("%6s %20s %6s %10s\n", "------", "--------------------", "------", "----------"); @errcounts = (); foreach my $pid (keys %writes) { foreach my $error (keys %{$writes{$pid}{errors}}) { my $comm = $writes{$pid}{comm} || ""; my $errcount = $writes{$pid}{errors}{$error} || 0; push @errcounts, [$pid, $comm, $error, $errcount]; } } @errcounts = sort { $b->[3] <=> $a->[3] } @errcounts; for my $i (0 .. $#errcounts) { printf("%6d %-20s %6d %10s\n", $errcounts[$i][0], $errcounts[$i][1], $errcounts[$i][2], $errcounts[$i][3]); } print_unhandled(); } my %unhandled; sub print_unhandled { if ((scalar keys %unhandled) == 0) { return; } print "\nunhandled events:\n\n"; printf("%-40s %10s\n", "event", "count"); printf("%-40s %10s\n", "----------------------------------------", "-----------"); foreach my $event_name (keys %unhandled) { printf("%-40s %10d\n", $event_name, $unhandled{$event_name}); } } sub trace_unhandled { my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs, $common_pid, $common_comm) = @_; $unhandled{$event_name}++; } rVinod Koul <vinod.koul@intel.com>2017-01-25 15:35:11 +0530 commit91539eb1fda2d530d3b268eef542c5414e54bf1a (patch) tree960f5ca6342ad20837aff18aad6e8ecd7da32fd6 /sound/soc/codecs/cs4271.h parent6610d0edf6dc7ee97e46ab3a538a565c79d26199 (diff)
dmaengine: pl330: fix double lock
The static bug finder EBA (http://www.iagoabal.eu/eba/) reported the following double-lock bug: Double lock: 1. spin_lock_irqsave(pch->lock, flags) at pl330_free_chan_resources:2236; 2. call to function `pl330_release_channel' immediately after; 3. call to function `dma_pl330_rqcb' in line 1753; 4. spin_lock_irqsave(pch->lock, flags) at dma_pl330_rqcb:1505. I have fixed it as suggested by Marek Szyprowski. First, I have replaced `pch->lock' with `pl330->lock' in functions `pl330_alloc_chan_resources' and `pl330_free_chan_resources'. This avoids the double-lock by acquiring a different lock than `dma_pl330_rqcb'. NOTE that, as a result, `pl330_free_chan_resources' executes `list_splice_tail_init' on `pch->work_list' under lock `pl330->lock', whereas in the rest of the code `pch->work_list' is protected by `pch->lock'. I don't know if this may cause race conditions. Similarly `pch->cyclic' is written by `pl330_alloc_chan_resources' under `pl330->lock' but read by `pl330_tx_submit' under `pch->lock'. Second, I have removed locking from `pl330_request_channel' and `pl330_release_channel' functions. Function `pl330_request_channel' is only called from `pl330_alloc_chan_resources', so the lock is already held. Function `pl330_release_channel' is called from `pl330_free_chan_resources', which already holds the lock, and from `pl330_del'. Function `pl330_del' is called in an error path of `pl330_probe' and at the end of `pl330_remove', but I assume that there cannot be concurrent accesses to the protected data at those points. Signed-off-by: Iago Abal <mail@iagoabal.eu> Reviewed-by: Marek Szyprowski <m.szyprowski@samsung.com> Signed-off-by: Vinod Koul <vinod.koul@intel.com>
Diffstat (limited to 'sound/soc/codecs/cs4271.h')