Instead of using a conditional, you could just store things in iteratively deeper hashes until you run out of elements in @data:

sub store_data {
    my( $root, $value, @key ) = @_;
    while( @key > 1 ) {
        $k = shift @key;
        $root->{ $k } ||= {};
        $root = $root->{ $k };
    };
    $root->{ $key[0] } = $value;
}

store_data( $devstats, $value, @data );
[download]

Update: Code was missing a line

How does this work, given that you are never changing @key and you never set $k? And doesn't $root = $root->{ $k }; just dereference rather than move the root?

Update: to answer my own questions - the previously missing line allows for the changes and the root moves because of the explicit creation of the sub-hashref. Good solution (++).

Semi-tested :)

#!/usr/bin/perl

# https://perlmonks.org/?node_id=1222210

use strict;
use warnings;

my $devstats;

readfile("/sys/class/net/dsl/statistics/rx_bytes");
readfile("/sys/class/net/dsl/mtu");
readfile("/sys/class/net/tybalt/mtu");
readfile("/sys/class/net/tybalt/statistics/rx_bytes");
readfile("/sys/class/net/dsl/queues/tx-0/byte_queue_limits/inflight");

use Data::Dumper; print Dumper $devstats;

exit(0);

sub readfile {
  my $file = shift;

  my @data = split("/", $file);
  my $nic = $data[4];

  open(FIFO, "< $file") or die "$! opening $file";
  my $value = <FIFO>;
  if (defined($value)) {
    chomp($value);
    my $hashref = \$devstats->{$nic};
    $hashref = \$$hashref->{$_} for @data[5 .. $#data];
    $$hashref = $value;
  }
  close(FIFO);
}
[download]

Outputs (on my system):

$VAR1 = {
          'tybalt' => {
                        'statistics' => {
                                          'rx_bytes' => '26296'
                                        },
                        'mtu' => '1500'
                      },
          'dsl' => {
                     'mtu' => '1500',
                     'queues' => {
                                   'tx-0' => {
                                               'byte_queue_limits' => 
+{
                                                                      
+  'inflight' => '0'
                                                                      
+}
                                             }
                                 },
                     'statistics' => {
                                       'rx_bytes' => '51353977825'
                                     }
                   }
        };
[download]

my $hashref = \$devstats->{$nic};
$hashref = \$$hashref->{$_} for @data[5..$#data];
$$hashref = $value;
[download]

should be

my $scalarref = \$devstats->{$nic};
$scalarref = \$$scalarref->{$_} for @data[5..$#data];
$$scalarref = $value;
[download]

This can be simplified to

my $scalarref = \$devstats;
$scalarref = \$$scalarref->{$_} for $nic, @data[5..$#data];
$$scalarref = $value;
[download]

or

my $scalarref = \$devstats;
$scalarref = \$$scalarref->{$_} for @data[4..$#data];
$$scalarref = $value;
[download]

This can be replaced with

sub dive_val :lvalue { my $p = \shift; $p = \$$p->{$_} for @_; $p }

dive_val($devstats, @data[4..$#data]) = $value;
[download]

or

use Data::Diver qw( DiveVal );

DiveVal($devstats //= {}, map \$_, @data[4..$#data]) = $value;
[download]

How these work is explained here.

This one works for me. Thanks!

The most direct translation would be to just use a temporary value to store how far down the tree you are. Something like (untested, but perl -c likes it):

if(defined($value)) {
    chomp($value);
    my $lval = $devstats->{$nic};
    for(my $i = $dirCnt ; $i >= 6 ; $i--) {
        $lval = $lval->{$data{$i-1}};
    }
    $lval->{$key} = $value;
}
[download]

Of course, that's a lot of magic numbers, so a better solution is probably to rearrange things to be a little more semantically meaningful. Perhaps in how the filename is assembled, and how you're passing it to readfile(), if that's possible? If not, preprocessing @data a little... it'll be longer, but probably clearer.

By the way, eq is for comparing strings, and == is for comparing numbers.