From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from gate001.proxmox.com (gate001.proxmox.com [IPv6:2a0f:8001:1:32::40]) by lore.proxmox.com (Postfix) with ESMTPS id 8C9181FF0AA for ; Tue, 17 Nov 2026 21:42:21 +0100 (CET) Received: from gate001.proxmox.com (localhost.localdomain [127.0.0.1]) by gate001.proxmox.com (Proxmox) with ESMTP id 84E5821841; Tue, 17 Nov 2026 21:40:54 +0100 (CET) From: "Max R. Carrara" To: pve-devel@lists.proxmox.com Subject: [PATCH pve-storage v3 15/51] storage: clean up code that was moved into helper in path_to_volume_id Date: Tue, 17 Nov 2026 21:38:47 +0100 Message-ID: <20261117203953.913035-16-m.carrara@proxmox.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20261117203953.913035-1-m.carrara@proxmox.com> References: <20261117203953.913035-1-m.carrara@proxmox.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Bm-Milter-Handled: 55990f41-d878-4baa-be0a-ee34c49e34d2 X-Bm-Transport-Timestamp: 1794948024982 X-SPAM-LEVEL: Spam detection results: 0 AWL 0.264 Adjusted score from AWL reputation of From: address DMARC_MISSING 0.1 Missing DMARC policy KAM_DMARC_STATUS 0.01 Test Rule for DKIM or SPF Failure with Strict Alignment (newer systems) RCVD_IN_DNSWL_MED -2.3 Sender listed at https://www.dnswl.org/, medium trust SPF_HELO_NONE 0.001 SPF: HELO does not publish an SPF Record SPF_PASS -0.001 SPF: sender matches SPF record Message-ID-Hash: PM5LGVY4JSFS4QAOSB74D55SWEVFROPV X-Message-ID-Hash: PM5LGVY4JSFS4QAOSB74D55SWEVFROPV X-MailFrom: m.carrara@proxmox.com X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; loop; banned-address; emergency; member-moderation; nonmember-moderation; administrivia; implicit-dest; max-recipients; max-size; news-moderation; no-subject; digests; suspicious-header CC: Wolfgang Bumiller X-Mailman-Version: 3.3.10 Precedence: list List-Id: Proxmox VE development discussion List-Help: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: In order to make the parsing logic in `path_to_volume_id()` both simpler and more manageable for future changes, do the following: 1. Iterate over a list of vtypes that store their contents in subdirectories and fetch said subdirectories dynamically instead of hardcoding them. 2. Explicitly exclude the `rootdir` vtype in this list of vtypes, as its subdirectory is currently not used. Since content directories may be nested inside one another, check the vtypes with the longest subdirectory first, so that a path belongs to the vtype whose subdirectory contains it most closely. 3. Strip the vtype subdirectory from the beginning of the path in order to make matching on the file name easier. Return early as a safeguard if this fails. 4. Adapt the original regexes in the parsing helper to not include the vtype subdir anymore, since this is now being stripped. Anchor them at the start of the remainder, so that files in subdirectories of a vtype subdir do not resolve to a volume directly inside it. Additionally, it is necessary to still return a (vtype, volid) pair in the new helper, because of the new `vm-vol`, `vm-state`, and `ct-vol` volume types. This only matters for the `images` case. Note that the parsing logic of the `parse_volid_from_file_path()` helper inside `path_to_volume_id()` now is very similar to the parsing logic of the `get_subdir_file_info()` closure in the `get_subdir_files()` helper inside `Plugin.pm`. This opens up further simplification / code de-duplication in the future, so that our parsing logic can eventually be kept in one place only. Signed-off-by: Max R. Carrara --- src/PVE/Storage.pm | 101 ++++++++++++++++++++++++++++++++++----------- 1 file changed, 76 insertions(+), 25 deletions(-) diff --git a/src/PVE/Storage.pm b/src/PVE/Storage.pm index f5c866db..39e72933 100755 --- a/src/PVE/Storage.pm +++ b/src/PVE/Storage.pm @@ -23,11 +23,13 @@ use PVE::JSONSchema; use PVE::INotify; use PVE::RPCEnvironment; use PVE::SSHInfo; use PVE::RESTEnvironment qw(log_warn); -use PVE::Storage::Common; +use PVE::Storage::Common qw( + plugin_get_default_vtype_subdirs +); use PVE::Storage::Plugin; use PVE::Storage::DirPlugin; use PVE::Storage::LVMPlugin; use PVE::Storage::LvmThinPlugin; use PVE::Storage::NFSPlugin; @@ -734,74 +736,123 @@ sub path_to_volume_id { # Note: abs_path() return undef if $path doesn not exist # for example when nfs storage is not mounted $path = abs_path($path) || $path; + my $get_vtypes_to_check = sub { + my ($plugin, $scfg) = @_; + + # TODO: vtype split: handle directory for 'rootdir' type. + # CTs currently use the same dir as VMs --> the dir for the 'images' type. + # Directory is therefore unused right now, so exclude it. + my $vtypes = [grep { $_ ne 'rootdir' } keys plugin_get_default_vtype_subdirs()->%*]; + + my $dir_lengths = {}; + for my $vtype ($vtypes->@*) { + # FIXME: Call plugin_get_vtype_subdir() instead of + # $plugin->get_subdir() on the next APIAGE reset. + my $subdir = $plugin->get_subdir($scfg, $vtype); + + # Note that we simply use the length of the directory without "/" + # separators here, because something like `foo/bar` is always + # longer than `foo`. IOW, a contained directory always has strictly + # more components. + # For "sibling" subdirs, e.g. `foo/bar` and `foo/baz`, the order + # doesn't matter. + # + # This is equivalent to counting the components of a path, but this + # method here should be faster. + $dir_lengths->{$vtype} = length($subdir =~ s!/+$!!r); + } + + my $order = { map { $vtypes->[$_] => $_ } 0 .. $vtypes->$#* }; + + return [ + sort { + $dir_lengths->{$b} <=> $dir_lengths->{$a} || $order->{$a} <=> $order->{$b} + } $vtypes->@* + ]; + }; + my $parse_volid_from_file_path = sub { - my ($plugin, $sid, $scfg) = @_; + my ($plugin, $sid, $scfg, $vtype) = @_; # FIXME: Call plugin_get_vtype_subdir() instead of $plugin->get_subdir() # on the next APIAGE reset. - my $imagedir = $plugin->get_subdir($scfg, 'images'); - my $isodir = $plugin->get_subdir($scfg, 'iso'); - my $tmpldir = $plugin->get_subdir($scfg, 'vztmpl'); - my $backupdir = $plugin->get_subdir($scfg, 'backup'); - my $snippetsdir = $plugin->get_subdir($scfg, 'snippets'); - my $importdir = $plugin->get_subdir($scfg, 'import'); + my $vtype_subdir = $plugin->get_subdir($scfg, $vtype); - if ($path =~ m!^\Q$imagedir\E/(\d+)/([^/\s]+)$!) { + # Strip the vtype subdir from beginning of the current path + # so that we don't have to take it into account when parsing the file name + my $filename = $path; + if ($filename !~ s!^\Q$vtype_subdir\E(?=/)!!) { + return; + } + + if ($vtype eq 'images') { + return if $filename !~ m!^/(\d+)/([^/\s]+)$!; my $vmid = $1; my $name = $2; my $vollist = $plugin->list_images($sid, $scfg, $vmid); for my $info ($vollist->@*) { my ($storeid, $volname) = parse_volume_id($info->{volid}); my $volpath = $plugin->path($scfg, $volname, $storeid); if ($volpath eq $path) { - my ($vtype) = $plugin->parse_volname($volname); - return ($vtype, $info->{volid}); + my ($parsed_vtype) = $plugin->parse_volname($volname); + return ($parsed_vtype, $info->{volid}); } } - return (''); + return; } - if ($path =~ m!^\Q$isodir\E/([^/]+$ISO_EXT_RE_0)$!) { + if ($vtype eq 'iso') { + return if $filename !~ m!^/([^/]+$ISO_EXT_RE_0)$!; my $name = $1; - return ('iso', "$sid:iso/$name"); + return ($vtype, "$sid:iso/$name"); } - if ($path =~ m!^\Q$tmpldir\E/([^/]+$VZTMPL_EXT_RE_1)$!) { + if ($vtype eq 'vztmpl') { + return if $filename !~ m!^/([^/]+$VZTMPL_EXT_RE_1)$!; my $name = $1; - return ('vztmpl', "$sid:vztmpl/$name"); + return ($vtype, "$sid:vztmpl/$name"); } - if ($path =~ m!^\Q$backupdir\E/([^/]+$BACKUP_EXT_RE_2)$!) { + if ($vtype eq 'backup') { + return if $filename !~ m!^/([^/]+$BACKUP_EXT_RE_2)$!; my $name = $1; - return ('backup', "$sid:backup/$name"); + return ($vtype, "$sid:backup/$name"); } - if ($path =~ m!^\Q$snippetsdir\E/([^/]+)$!) { + if ($vtype eq 'snippets') { + return if $filename !~ m!^/([^/]+)$!; my $name = $1; - return ('snippets', "$sid:snippets/$name"); + return ($vtype, "$sid:snippets/$name"); } - if ($path =~ m!^\Q$importdir\E/(${SAFE_CHAR_CLASS_RE}+${IMPORT_EXT_RE_1})$!) { + if ($vtype eq 'import') { + return if $filename !~ m!^/(${SAFE_CHAR_CLASS_RE}+${IMPORT_EXT_RE_1})$!; my $name = $1; - return ('import', "$sid:import/$name"); + return ($vtype, "$sid:import/$name"); } - return (''); + return; }; for my $sid (keys $ids->%*) { my $scfg = $ids->{$sid}; next if !$scfg->{path}; my $plugin = PVE::Storage::Plugin->lookup($scfg->{type}); - my ($vtype, $volid) = $parse_volid_from_file_path->($plugin, $sid, $scfg); - return ($vtype, $volid) if $vtype; + for my $vtype ($get_vtypes_to_check->($plugin, $scfg)->@*) { + my ($actual_vtype, $volid) = + $parse_volid_from_file_path->($plugin, $sid, $scfg, $vtype); + + if (defined($volid)) { + return ($actual_vtype, $volid); + } + } } # can't map path to volume id return (''); } -- 2.47.3