commit 88a11a0dcd81fa00bf2f733695b2117da112f2e4 · pyrox.dev/nixpkgs

+3 -1

nixos/doc/manual/development/what-happens-during-a-system-switch.chapter.md

···

       46
        
       

     

       47
        
       By default, some units are filtered from the outputs to make it less spammy.

     

       48
        
       This can be disabled for development or testing by setting the environment variable

     

       49
       -
       `STC_DISPLAY_ALL_UNITS=1`

     

       0
        
       
     

       0
        
       
     

       50
        
       

     

       51
        
       Most of these actions are either self-explaining but some of them have to do

     

       52
        
       with our units or the activation script. For this reason, these topics are

···

       46
        
       

     

       47
        
       By default, some units are filtered from the outputs to make it less spammy.

     

       48
        
       This can be disabled for development or testing by setting the environment variable

     

       49
       +
       `STC_DISPLAY_ALL_UNITS=1`.

     

       50
       +
       

     

       51
       +
       More detailed output can be displayed by setting `STC_DEBUG=1`.

     

       52
        
       

     

       53
        
       Most of these actions are either self-explaining but some of them have to do

     

       54
        
       with our units or the activation script. For this reason, these topics are

+21 -1

pkgs/by-name/sw/switch-to-configuration-ng/src/src/main.rs

···

       909
        
           submitted_jobs: &Rc<RefCell<HashMap<dbus::Path<'static>, Job>>>,

     

       910
        
       ) {

     

       911
        
           while !submitted_jobs.borrow().is_empty() {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       912
        
               _ = conn.process(Duration::from_millis(500));

     

       913
        
           }

     

       914
        
       }

     
···

       961
        
               .restart_unit("nixos-activation.service", "replace")

     

       962
        
               .context("Failed to restart nixos-activation.service")?;

     

       963
        
       

     

       0
        
       
     

       964
        
           while !*nixos_activation_done.borrow() {

     

       965
        
               _ = dbus_conn

     

       966
        
                   .process(Duration::from_secs(500))

     
···

       989
        
       

     

       990
        
       /// Performs switch-to-configuration functionality for the entire system

     

       991
        
       fn do_system_switch(action: Action) -> anyhow::Result<()> {

     

       0
        
       
     

       0
        
       
     

       992
        
           let out = PathBuf::from(required_env("OUT")?);

     

       993
        
           let toplevel = PathBuf::from(required_env("TOPLEVEL")?);

     

       994
        
           let distro_id = required_env("DISTRO_ID")?;

     
···

       996
        
           let install_bootloader = required_env("INSTALL_BOOTLOADER")?;

     

       997
        
           let locale_archive = required_env("LOCALE_ARCHIVE")?;

     

       998
        
           let new_systemd = PathBuf::from(required_env("SYSTEMD")?);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       999
        
       

     

       1000
        
           let action = ACTION.get_or_init(|| action);

     

       0
        
       
     

       1001
        
       

     

       1002
        
           // The action that is to be performed (like switch, boot, test, dry-activate) Also exposed via

     

       1003
        
           // environment variable from now on

     
···

       1029
        
           std::fs::set_permissions("/run/nixos", perms)

     

       1030
        
               .context("Failed to set permissions on /run/nixos directory")?;

     

       1031
        
       

     

       0
        
       
     

       1032
        
           let Ok(lock) = std::fs::OpenOptions::new()

     

       1033
        
               .append(true)

     

       1034
        
               .create(true)

     
···

       1038
        
               die();

     

       1039
        
           };

     

       1040
        
       

     

       0
        
       
     

       1041
        
           let Ok(_lock) = Flock::lock(lock, FlockArg::LockExclusiveNonblock) else {

     

       1042
        
               eprintln!("Could not acquire lock");

     

       1043
        
               die();

     

       1044
        
           };

     

       1045
        
       

     

       1046
       -
           if syslog::init(Facility::LOG_USER, LevelFilter::Debug, Some("nixos")).is_err() {

     

       1047
        
               bail!("Failed to initialize logger");

     

       1048
        
           }

     

       1049
        
       

     
···

       1053
        
               != "1"

     

       1054
        
           {

     

       1055
        
               do_pre_switch_check(&pre_switch_check, &toplevel, action)?;

     

       0
        
       
     

       1056
        
           }

     

       1057
        
       

     

       1058
        
           if *action == Action::Check {

     
···

       1062
        
           // Install or update the bootloader.

     

       1063
        
           if matches!(action, Action::Switch | Action::Boot) {

     

       1064
        
               do_install_bootloader(&install_bootloader, &toplevel)?;

     

       0
        
       
     

       1065
        
           }

     

       1066
        
       

     

       1067
        
           // Just in case the new configuration hangs the system, do a sync now.

     
···

       1642
        
               eprintln!("restarting systemd...");

     

       1643
        
               _ = systemd.reexecute(); // we don't get a dbus reply here

     

       1644
        
       

     

       0
        
       
     

       1645
        
               while !*systemd_reload_status.borrow() {

     

       1646
        
                   _ = dbus_conn

     

       1647
        
                       .process(Duration::from_millis(500))

     
···

       1656
        
       

     

       1657
        
           // Make systemd reload its units.

     

       1658
        
           _ = systemd.reload(); // we don't get a dbus reply here

     

       0
        
       
     

       1659
        
           while !*systemd_reload_status.borrow() {

     

       1660
        
               _ = dbus_conn

     

       1661
        
                   .process(Duration::from_millis(500))

     
···

       1692
        
                           .canonicalize()

     

       1693
        
                           .context("Failed to get full path to /proc/self/exe")?;

     

       1694
        
       

     

       0
        
       
     

       1695
        
                       std::process::Command::new(&myself)

     

       1696
        
                           .uid(uid)

     

       1697
        
                           .gid(gid)

···

       909
        
           submitted_jobs: &Rc<RefCell<HashMap<dbus::Path<'static>, Job>>>,

     

       910
        
       ) {

     

       911
        
           while !submitted_jobs.borrow().is_empty() {

     

       912
       +
               log::debug!(

     

       913
       +
                   "waiting for submitted jobs to finish, still have {} job(s)",

     

       914
       +
                   submitted_jobs.borrow().len()

     

       915
       +
               );

     

       916
        
               _ = conn.process(Duration::from_millis(500));

     

       917
        
           }

     

       918
        
       }

     
···

       965
        
               .restart_unit("nixos-activation.service", "replace")

     

       966
        
               .context("Failed to restart nixos-activation.service")?;

     

       967
        
       

     

       968
       +
           log::debug!("waiting for nixos activation to finish");

     

       969
        
           while !*nixos_activation_done.borrow() {

     

       970
        
               _ = dbus_conn

     

       971
        
                   .process(Duration::from_secs(500))

     
···

       994
        
       

     

       995
        
       /// Performs switch-to-configuration functionality for the entire system

     

       996
        
       fn do_system_switch(action: Action) -> anyhow::Result<()> {

     

       997
       +
           log::debug!("Performing system switch");

     

       998
       +
       

     

       999
        
           let out = PathBuf::from(required_env("OUT")?);

     

       1000
        
           let toplevel = PathBuf::from(required_env("TOPLEVEL")?);

     

       1001
        
           let distro_id = required_env("DISTRO_ID")?;

     
···

       1003
        
           let install_bootloader = required_env("INSTALL_BOOTLOADER")?;

     

       1004
        
           let locale_archive = required_env("LOCALE_ARCHIVE")?;

     

       1005
        
           let new_systemd = PathBuf::from(required_env("SYSTEMD")?);

     

       1006
       +
           let log_level = if std::env::var("STC_DEBUG").is_ok() {

     

       1007
       +
               LevelFilter::Debug

     

       1008
       +
           } else {

     

       1009
       +
               LevelFilter::Info

     

       1010
       +
           };

     

       1011
        
       

     

       1012
        
           let action = ACTION.get_or_init(|| action);

     

       1013
       +
           log::debug!("Using action {:?}", action);

     

       1014
        
       

     

       1015
        
           // The action that is to be performed (like switch, boot, test, dry-activate) Also exposed via

     

       1016
        
           // environment variable from now on

     
···

       1042
        
           std::fs::set_permissions("/run/nixos", perms)

     

       1043
        
               .context("Failed to set permissions on /run/nixos directory")?;

     

       1044
        
       

     

       1045
       +
           log::debug!("Creating lock file /run/nixos/switch-to-configuration.lock");

     

       1046
        
           let Ok(lock) = std::fs::OpenOptions::new()

     

       1047
        
               .append(true)

     

       1048
        
               .create(true)

     
···

       1052
        
               die();

     

       1053
        
           };

     

       1054
        
       

     

       1055
       +
           log::debug!("Acquiring lock on file /run/nixos/switch-to-configuration.lock");

     

       1056
        
           let Ok(_lock) = Flock::lock(lock, FlockArg::LockExclusiveNonblock) else {

     

       1057
        
               eprintln!("Could not acquire lock");

     

       1058
        
               die();

     

       1059
        
           };

     

       1060
        
       

     

       1061
       +
           if syslog::init(Facility::LOG_USER, log_level, Some("nixos")).is_err() {

     

       1062
        
               bail!("Failed to initialize logger");

     

       1063
        
           }

     

       1064
        
       

     
···

       1068
        
               != "1"

     

       1069
        
           {

     

       1070
        
               do_pre_switch_check(&pre_switch_check, &toplevel, action)?;

     

       1071
       +
               log::debug!("Done performing pre-switch checks");

     

       1072
        
           }

     

       1073
        
       

     

       1074
        
           if *action == Action::Check {

     
···

       1078
        
           // Install or update the bootloader.

     

       1079
        
           if matches!(action, Action::Switch | Action::Boot) {

     

       1080
        
               do_install_bootloader(&install_bootloader, &toplevel)?;

     

       1081
       +
               log::debug!("Done performing bootloader installation");

     

       1082
        
           }

     

       1083
        
       

     

       1084
        
           // Just in case the new configuration hangs the system, do a sync now.

     
···

       1659
        
               eprintln!("restarting systemd...");

     

       1660
        
               _ = systemd.reexecute(); // we don't get a dbus reply here

     

       1661
        
       

     

       1662
       +
               log::debug!("waiting for systemd restart to finish");

     

       1663
        
               while !*systemd_reload_status.borrow() {

     

       1664
        
                   _ = dbus_conn

     

       1665
        
                       .process(Duration::from_millis(500))

     
···

       1674
        
       

     

       1675
        
           // Make systemd reload its units.

     

       1676
        
           _ = systemd.reload(); // we don't get a dbus reply here

     

       1677
       +
           log::debug!("waiting for systemd reload to finish");

     

       1678
        
           while !*systemd_reload_status.borrow() {

     

       1679
        
               _ = dbus_conn

     

       1680
        
                   .process(Duration::from_millis(500))

     
···

       1711
        
                           .canonicalize()

     

       1712
        
                           .context("Failed to get full path to /proc/self/exe")?;

     

       1713
        
       

     

       1714
       +
                       log::debug!("Performing user switch for {name}");

     

       1715
        
                       std::process::Command::new(&myself)

     

       1716
        
                           .uid(uid)

     

       1717
        
                           .gid(gid)