Neither backticks (qx) or system return control to the perl program until they exit. You will have to do your own fork() call so the parent perl program can do something while the child is running. Here's a small example of a parent sending SIGINT (what control-c sends) to a child.

Hope this helps...

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11165441
use warnings;
$SIG{__WARN__} = sub { die @_ };

if( my $pid = fork )
  {                    # parent
  sleep 1;
  kill 'INT', $pid;
  sleep 1;
  kill 'INT', $pid;
  sleep 1;
  kill 'TERM', $pid;
  print "parent waiting for child to exit\n";
  wait;
  print "parent exited\n";
  }
elsif( defined $pid )
  {                    # child
  print "child started\n";
  $SIG{INT} = sub { print "child got SIGINT\n" };
  $SIG{TERM} = sub { print "child got SIGTERM\n"; exit };
  sleep 1 while 1;
  }
else
  {
  die "fork failed";
  }
[download]

See my node Calling External Commands More Safely: IMHO on Linux IPC::Run is the best way to manage external commands while your Perl script does something else, like sending that process a signal (as others have pointed out, Ctrl-C is SIGINT):

#!/usr/bin/env perl
use warnings;
use strict;
use IPC::Run qw/start/;

print "Starting trace-cmd...\n";
my @cmd = ('sudo','trace-cmd','record',
    '-p','function','-cP',$$);  # just an example
my $h = start \@cmd, \my $stdin, \my $stdout, \my $stderr;

# wait for trace-cmd to say something before continuing
$h->pump until length $stdout || length $stderr;
#print "<<$stdout||$stderr>>\n";  # just for debugging

# This sleep is just a stand-in for something more complex
print "Waiting 2 seconds...\n";
sleep 2;

print "Sending SIGINT...\n";
$h->signal('INT');

print "Finishing...\n";
$h->finish or die "trace-cmd record returned $?";

print "Done, resetting...\n";
system('sudo','trace-cmd','reset')==0
    or die "trace-cmd reset returned $?";
[download]

If i kill the process; that does not seem to get handled by trace-cmd in the same way as doing a control c.

Different signals are handled differently. The default sent by kill is SIGTERM whereas ^C is usually bound to SIGINT. Try using kill -INT from the shell and you should get the same effect as ^C.

If you use exec or system to start the subprocess then it will receive the SIGINTs sent by the controlling shell (eg. by entering ^C) and there is nothing special which you need to do in the Perl parent to achieve this behaviour.

To demonstrate, here is inttest.pl followed by inttrap.sh. Make them both executable and then run the former. You will see that your ^C keypresses successfully send SIGINTS to the child shell script.

#!/usr/bin/env perl
use strict;
use warnings;

print "With system ():\n";
system "./inttrap.sh";

print "With exec ():\n";
exec "./inttrap.sh";
[download]

#!/bin/bash

trap "echo interrupted" 2

for i in {1..5}
do
    sleep 1
    echo Waiting $i ...
done
[download]

This article might be useful: https://www.perl.com/article/37/2013/8/18/Catch-and-Handle-Signals-in-Perl. See also https://perldoc.perl.org/sigtrap.