/usr/local/cpanel/scripts
Edit: /usr/local/cpanel/scripts/fixquotas (18834B)
#!/usr/local/cpanel/3rdparty/bin/perl
# cpanel - scripts/fixquotas Copyright 2022 cPanel, L.L.C.
# All rights reserved.
# copyright@cpanel.net http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
package Scripts::FixQuotas;
use cPstrict;
use Cwd ();
use IO::File ();
use Scalar::Util ();
use Cpanel::Binaries ();
use Cpanel::FindBin ();
use Cpanel::Filesys::FindParse ();
use Cpanel::Filesys::Info ();
use Cpanel::SafeRun::Errors ();
use Cpanel::OS ();
use Cpanel::Filesys::Root ();
use Cpanel::LoadFile ();
use Cpanel::Fcntl::Constants ();
use Cpanel::SafeRun::Object ();
use Cpanel::SetEnvLocale ();
use Cpanel::ServerTasks ();
use Cpanel::Transaction::File::Raw ();
use Cpanel::SafeDir::MK ();
use Cpanel::Notify ();
use Cpanel::FileUtils::Touch ();
use Cpanel::Kernel::Status ();
use Cpanel::Pkgr ();
use Cpanel::SysPkgs ();
# For testing purposes
our $PROC_MOUNTS = Cwd::realpath('/proc/mounts');
our $UDEV_RULES_DIR = "/etc/udev/rules.d";
our $UDEV_LINK_RULES_FILE = "$UDEV_RULES_DIR/99-root-link.rules";
our $REBOOT_TOUCH_FILE = "/var/cpanel/reboot_required_for_quota";
our $BROKEN_TOUCH_FILE = "/var/cpanel/quota_broken";
our $DEFAULT_GRUB_CONFIG = '/etc/default/grub';
our %cmd = (
'quotaon' => undef,
'quotaoff' => undef,
);
use constant { CONTINUED_SUCCESS => 1, NEW_SUCCESS => 2 };
exit run(@ARGV) unless caller();
sub run (@args) {
my $onboot = grep { $_ eq '--onboot' } @args;
return 0 if !verify_quota_binaries();
if ($onboot) {
if ( enable_quotas() == NEW_SUCCESS ) { # dies on failures
Cpanel::Notify::notification_class( 'class' => 'Quota::SetupComplete', 'application' => 'Quota::SetupComplete', 'constructor_args' => [] );
}
return 0;
}
Cpanel::SafeRun::Errors::saferunnoerror( $cmd{'quotaoff'}, '-a' );
fix_broken_dev_root_links();
initialize_quotas();
enable_quotas();
return 0;
}
sub get_xfs_mount_points_without_quota {
my @lines = grep { /\bxfs\b.*\bnoquota\b/ } Cpanel::SafeRun::Errors::saferunnoerror('/bin/mount');
my @partitions;
foreach my $line (@lines) {
push @partitions, $1 if $line =~ /^\S+\s+on\s+(\S+)/;
}
return @partitions;
}
# Find the XFS partitions with uquota (but not noquota) set in fstab.
sub get_xfs_mount_points_fstab_quota {
my @xfs = grep { $_->{'fstype'} eq 'xfs' } Cpanel::Filesys::FindParse::parse_fstab();
return map { $_->{mountpoint} } grep {
my $obj = $_;
my $opts = { map { $_ => 1 } @{ $obj->{'options'} } };
$opts->{'uquota'} && !$opts->{'noquota'};
} @xfs;
}
sub fix_broken_dev_root_links {
if ( !-e $PROC_MOUNTS || !-r $PROC_MOUNTS ) {
return 0;
}
my @lines = split qq{\n}, Cpanel::LoadFile::load($PROC_MOUNTS) or die "Unable to open $PROC_MOUNTS: $!";
#
# Danger: This code is targeted to fix systems that have
# /dev/root (AKA Cpanel::Filesys::Root::DEV_ROOT) in /proc/mounts
#
# If it is refactored to fix other system additional coverage will
# be needed esp for handling roots like /dev/mapper/Vol....
#
foreach my $line (@lines) {
my ( $device, $mount, $type, undef ) = split( /\s+/, $line, 4 );
if ( defined $device && $device eq $Cpanel::Filesys::Root::DEV_ROOT && !-e $Cpanel::Filesys::Root::DEV_ROOT ) {
my $actual_root_device_path = Cpanel::Filesys::Root::get_root_device_path();
#If $DEV_ROOT is a symlink that doesn’t resolve,
#whether it’s a dangling symlink,
#a symlink to a dangling symlink, or part of a symlink loop,
#then get rid of it.
if ( -l $Cpanel::Filesys::Root::DEV_ROOT && !-e $Cpanel::Filesys::Root::DEV_ROOT ) {
unlink $Cpanel::Filesys::Root::DEV_ROOT or warn "unlink($Cpanel::Filesys::Root::DEV_ROOT): $!";
}
symlink( $actual_root_device_path, $Cpanel::Filesys::Root::DEV_ROOT ) or warn "symlink($actual_root_device_path, $Cpanel::Filesys::Root::DEV_ROOT): $!";
Cpanel::SafeDir::MK::safemkdir( $UDEV_RULES_DIR, 0755 );
my ($device_name) = $actual_root_device_path =~ m{^/[^/]+/(.*)$}; # /dev/(XXXXX......)
my $trans_obj = Cpanel::Transaction::File::Raw->new( path => $UDEV_LINK_RULES_FILE, 'permissions' => 0644 );
my $contents_ref = $trans_obj->get_data();
my $new_line = qq{KERNEL == "$device_name", SUBSYSTEM == "block", SYMLINK += "root"};
# In the event /dev/root was a symlink to /dev/root we need to make sure
# we remove any circular lines
my $circular_bad_line = qq{echo ' KERNEL == "root", SUBSYSTEM == "block", SYMLINK += "root"'};
my $circular_bad_line_without_space = qq{echo 'KERNEL == "root", SUBSYSTEM == "block", SYMLINK += "root"'};
my @lines = grep {
$_ ne $new_line # Trying to be narrow to remove only things we have added
&& $_ ne $circular_bad_line # Trying to be narrow to remove only things we have added
&& $_ ne $circular_bad_line_without_space # Trying to be narrow to remove only things we have added
} split( m{\n}, $$contents_ref );
push @lines, $new_line;
my $new_contents = join( "\n", @lines ) . "\n";
$trans_obj->set_data( \$new_contents );
$trans_obj->save_and_close_or_die();
last;
}
}
return 1;
}
sub initialize_quotas { ##no critic (Subroutines::ProhibitExcessComplexity)
# need to init quotas before a boot on xfs, to avoid to reboot for each partitions
Cpanel::SafeRun::Object->new_or_die(
program => '/usr/local/cpanel/scripts/initquotas',
stdout => \*STDOUT,
stderr => \*STDERR,
);
my $filesys_ref = Cpanel::Filesys::Info::all_filesystem_info();
my $slash_is_xfs = index( $filesys_ref->{'/'}{'fstype'}, 'xfs' ) > -1 ? 1 : 0;
if ( Cpanel::OS::has_quota_support_for_xfs() ) {
my %xfs_without_quota = map { $_ => 1 } get_xfs_mount_points_without_quota();
my $xfs_partition_without_quota = %xfs_without_quota ? 1 : 0;
my $grub2_cfg = find_grub2_cfg_file();
# do kernel mod? #
if ( $slash_is_xfs && $xfs_partition_without_quota && $grub2_cfg ) {
# at least one file system is XFS, so we'll need to enable quotas on the root file system before it's remounted by initrd and have the #
# user reboot to activate this change. it's not enough to remount the root filesystem, or any other, it must be completely remounted! #
my $grub_conf;
{
local $/ = undef;
open my $grub_fh, '<', $DEFAULT_GRUB_CONFIG
or die "The system failed to open the $DEFAULT_GRUB_CONFIG file: $!";
$grub_conf = <$grub_fh>;
close $grub_fh;
}
my $grub_conf_has_quota = $grub_conf =~ m/GRUB_CMDLINE_LINUX.+?rootflags.+?u(sr)?quota/ ? 1 : 0;
my $has_cloudlinux_enhanced_quotas = Cpanel::OS::has_cloudlinux_enhanced_quotas();
my $grub_cloudlinux_has_quota = 1;
# running /usr/sbin/grub2-mkconfig to update /boot/grub2/grub.cfg
# will not preserve the linux kernel, let's patch it manually
# we need to adjust the flags each time cloudlinux update the menuentry
my $found_cl_entry;
if ($has_cloudlinux_enhanced_quotas) {
print "CloudLinux system detected: adding/checking 'rootflags=uquota' to $grub2_cfg\n";
# Don't use safelock or transactions here, as those use link(2),
# and we may be on a vfat filesystem (for EFI) which doesn't
# support link(2).
my $fh = IO::File->new( $grub2_cfg, '+<' );
die "Could not open '$grub2_cfg' file: $!" unless flock( $fh, $Cpanel::Fcntl::Constants::LOCK_EX );
my @lines;
my $in_cl_entry;
# add rootflags=uquota to cloudlinux entries
while ( my $line = readline $fh ) {
# begin of cloudlinux menuentry
if ( !$in_cl_entry && $line =~ qr{^\s*menuentry 'CloudLinux\b}i ) {
$in_cl_entry = 1;
$found_cl_entry = 1;
}
# end of cloudlinux menuentry
if ( $in_cl_entry && $line !~ qr{^#} && $line =~ qr/}/ ) {
$in_cl_entry = 0;
}
# manually add the rootflags to the cloudlinux entries
# we can consider to also add them to other entries
if ( $in_cl_entry
&& $line =~ qr{^\s*linux([0-9]+|efi) (/boot)?/vmlinuz}i
&& $line !~ qr{rootflags.+?u(sr)?quota}i ) {
chomp $line;
$line .= qq{ rootflags=uquota\n};
$grub_cloudlinux_has_quota = 0;
}
push @lines, $line;
}
if ( $grub_cloudlinux_has_quota == 0 ) {
seek $fh, 0, 0;
print {$fh} join( '', @lines );
truncate( $fh, tell $fh );
}
flock( $fh, $Cpanel::Fcntl::Constants::LOCK_UN );
undef $fh;
}
# only need to adjust the grub2 configuration file if / is an xfs partition
# we need to reboot in all cases when enabling quota on xfs
if ( !$grub_conf_has_quota || ( $has_cloudlinux_enhanced_quotas && !$grub_cloudlinux_has_quota || ( $has_cloudlinux_enhanced_quotas && !$found_cl_entry ) ) ) {
if ( !$grub_conf_has_quota || ( $has_cloudlinux_enhanced_quotas && !$found_cl_entry ) ) {
# we need to modify /etc/default/grub to add user quotas, then re-generate the grub.cfg in /boot and finally reboot the system #
print qq{Modifying the $DEFAULT_GRUB_CONFIG file to enable user quotas...\n};
$grub_conf =~ s/GRUB_CMDLINE_LINUX="(.+?)"/GRUB_CMDLINE_LINUX="$1 rootflags=uquota"/m;
die qq{You must manually add or update "rootflags=uquota" to "GRUB_CMDLINE_LINUX" in the $DEFAULT_GRUB_CONFIG file, and re-run this tool.\n}
if $grub_conf !~ m/GRUB_CMDLINE_LINUX.+?rootflags.+?u(sr)?quota/;
open my $grubw_fh, '>', $DEFAULT_GRUB_CONFIG
or die "failed to open $DEFAULT_GRUB_CONFIG for writing: $!";
print {$grubw_fh} $grub_conf;
close $grubw_fh;
my $method = Cpanel::OS::program_to_apply_kernel_args();
if ( !$method ) {
die "Current OS does not have a value set for Cpanel::OS::program_to_apply_kernel_args";
}
elsif ( $method ne 'none' ) {
$method =~ tr/-/_/;
if ( my $cr = Scripts::FixQuotas->can("handle_$method") ) {
$cr->(
'config_file' => $grub2_cfg,
);
}
else {
die "I don't know how to handle_$method!";
}
}
}
_touch_reboot_and_notify();
# the script must quit at this time and ask the user to reboot to enable quotas #
die "\nThe '/' partition uses the XFS® filesystem. You must reboot the server to enable quotas.\n";
}
}
# If we have entries with quota enabled in fstab that aren't currently using
# quota, then we need to reboot.
if ( grep { $xfs_without_quota{$_} } get_xfs_mount_points_fstab_quota() ) {
_touch_reboot_and_notify();
die "\nYou must reboot the server to enable XFS® filesystem quotas.\n";
}
}
system '/usr/local/cpanel/scripts/resetquotas';
return;
}
sub handle_grub_mkconfig {
my %args = @_;
die "needs config_file argument" unless exists $args{config_file};
my $program = Cpanel::OS::program_to_apply_kernel_args();
print qq{Running the "$program" command to regenerate the system's boot configuration...\n};
die "/boot is not mounted. Mount /boot and then re-run this tool.\n"
if !-f $args{config_file};
Cpanel::SafeRun::Object->new_or_die(
program => Cpanel::OS::bin_grub_mkconfig(),
args => [ '-o', $args{config_file} ],
stdout => \*STDOUT,
stderr => \*STDERR,
);
return;
}
# alias
sub handle_grub2_mkconfig { goto &handle_grub_mkconfig }
sub handle_grubby {
my %args = @_;
print qq{Adding arguments to every kernel's boot entry using the "grubby" command...\n};
die "/boot/loader/entries does not exist. Ensure /boot is mounted and then re-run this tool.\n"
if !-d '/boot/loader/entries';
Cpanel::SafeRun::Object->new_or_die(
program => Cpanel::Binaries::path('grubby'),
args => [qw(--update-kernel=ALL --args=rootflags=uquota)],
stdout => \*STDOUT,
stderr => \*STDERR,
);
return;
}
sub _touch_reboot_and_notify {
Cpanel::FileUtils::Touch::touch_if_not_exists($REBOOT_TOUCH_FILE);
Cpanel::Notify::notification_class(
'class' => 'Quota::RebootRequired',
'application' => 'Quota::RebootRequired',
'constructor_args' => []
);
Cpanel::ServerTasks::schedule_task( ['SystemTasks'], 5, "recache_system_reboot_data" );
return;
}
sub _touch_broken_and_notify {
Cpanel::FileUtils::Touch::touch_if_not_exists($BROKEN_TOUCH_FILE);
Cpanel::Notify::notification_class(
'class' => 'Quota::Broken',
'application' => 'Quota::Broken',
'constructor_args' => []
);
# For now, broken notification is live, so no taskqueue stuff.
return;
}
sub _attempt_to_enable_quota {
# Force output to be english so our regular expressions
# used on stderr will work
my $env_locale = Cpanel::SetEnvLocale->new();
my $quotaon = Cpanel::SafeRun::Object->new(
program => $cmd{'quotaon'},
args => ['-a'],
);
# If there wasn't a problem with quotaon, everything is good.
return _quota_are_working() if $quotaon->CHILD_ERROR == 0;
my $stderr = $quotaon->stderr() // '';
# addon packages need to be installed
return if $stderr =~ m/^quotaon:(?:.*): No such process$/am;
# quota are already enabled
return _quota_are_working() if $stderr =~ m/^quotaon:(?:.*): Device or resource busy$/am;
$quotaon->die_if_error();
return;
}
sub _quota_are_working {
my $count = unlink( $REBOOT_TOUCH_FILE, $BROKEN_TOUCH_FILE );
Cpanel::ServerTasks::schedule_task( ['SystemTasks'], 5, "recache_system_reboot_data" );
return $count > 0 ? NEW_SUCCESS : CONTINUED_SUCCESS;
}
sub enable_quotas {
my $result;
return $result if $result = _attempt_to_enable_quota();
# Otherwise, it is clear that quotaon is receiving ESRCH when trying to turn quotas on, meaning that it doesn't recognize the file format.
# Try installing packages containing needed kernel modules if that hasn't been done and then starting over.
_install_quota_packages_conditional_if_needed();
return $result if $result = _attempt_to_enable_quota();
# Even after installing modules, quotaon is stil encountering ESRCH. Time to give up.
# However, it still must be determined what further steps to recommend.
# TODO: Replace kernel_status() with reboot_status() once CPANEL-39706 is fixed.
if ( Cpanel::Kernel::Status::kernel_status()->{'reboot_required'} ) {
_touch_reboot_and_notify();
die <<~'EOS';
The system is missing kernel modules needed to support quotas.
The system installed packages to try to address this, but a system reboot may be required.
For more information, see https://go.cpanel.net/fixquotas
EOS
}
else {
_touch_broken_and_notify();
die <<~'EOS';
The system is missing kernel modules needed to support quotas.
The system could not resolve this issue automatically.
For more information, see https://go.cpanel.net/fixquotas
EOS
}
}
sub _install_quota_packages_conditional_if_needed {
my %pkg_map = Cpanel::OS::quota_packages_conditional()->%*;
my @pkgs_to_install;
foreach my $pkg ( keys %pkg_map ) {
# install the extra if the main one is installed
next unless Cpanel::Pkgr::is_installed($pkg);
foreach my $extra ( $pkg_map{$pkg}->@* ) {
push @pkgs_to_install, $extra unless Cpanel::Pkgr::is_installed($extra);
}
}
return 0 unless scalar @pkgs_to_install;
# Use the custom error handler to get back the saferun object on failure:
my $syspkgs_obj = Cpanel::SysPkgs->new( exclude_options => { kernel => 0 } );
my $saferun_obj = $syspkgs_obj->install_packages( packages => \@pkgs_to_install, handle_child_error => sub { return $_[0] } );
if ( Scalar::Util::blessed($saferun_obj) && $saferun_obj->CHILD_ERROR() ) {
print "Packages failed to install. Retrying...\n";
sleep 5;
$syspkgs_obj->install_packages( packages => \@pkgs_to_install );
}
return;
}
sub verify_quota_binaries {
my @missing_cmds;
foreach my $cmd_name ( keys %cmd ) {
$cmd{$cmd_name} = Cpanel::FindBin::findbin($cmd_name);
if ( !defined $cmd{$cmd_name} || !-e $cmd{$cmd_name} || !-x $cmd{$cmd_name} ) {
push @missing_cmds, $cmd_name;
}
}
if ( scalar @missing_cmds ) {
print "Incomplete quota kit: unable to fix quotas.\n";
print 'Missing commands: ', join( ', ', @missing_cmds ), "\n";
return 0;
}
return 1;
}
sub find_grub2_cfg_file {
my @files = map { ( "$_/grub.cfg", "$_/grub2.cfg", "$_/grub2-efi.cfg" ) } (qw{/boot/efi/EFI/centos /boot/grub2 /etc});
foreach my $file (@files) {
return $file if -f $file;
}
return $files[-1];
}
1;