···

       
18
       
18
       
 
       


     

       
19
       
19
       
 
       
    let out_path = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());

     

       
20
       
20
       
 
       


     

       
21
       
21
       
-
       
    let fdo_dbus_code = code_for_dbus_xml("org.freedesktop.DBus.xml");

     

       
22
       
22
       
-
       
    let mut file = std::fs::File::create(out_path.join("fdo_dbus.rs")).unwrap();

     

       
23
       
23
       
-
       
    file.write_all(fdo_dbus_code.as_bytes()).unwrap();

     

       
24
       
24
       
-
       


     

       
25
       
21
       
 
       
    let systemd_manager_code =

     

       
26
       
22
       
 
       
        code_for_dbus_xml(systemd_dbus_interface_dir.join("org.freedesktop.systemd1.Manager.xml"));

     

       
27
       
23
       
 
       
    let mut file = std::fs::File::create(out_path.join("systemd_manager.rs")).unwrap();

     

···

       
1
       
1
       
-
       
<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"

     

       
2
       
2
       
-
       
"https://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">

     

       
3
       
3
       
-
       
<node>

     

       
4
       
4
       
-
       
  <!-- From https://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-messages. -->

     

       
5
       
5
       
-
       
  <interface name="org.freedesktop.DBus">

     

       
6
       
6
       
-
       
    <signal name="NameOwnerChanged">

     

       
7
       
7
       
-
       
      <arg type="s" direction="out" name="name"/>

     

       
8
       
8
       
-
       
      <arg type="s" direction="out" name="old_owner"/>

     

       
9
       
9
       
-
       
      <arg type="s" direction="out" name="new_owner"/>

     

       
10
       
10
       
-
       
    </signal>

     

       
11
       
11
       
-
       
  </interface>

     

       
12
       
12
       
-
       
</node>

     

···

       
17
       
17
       
 
       
use anyhow::{anyhow, bail, Context, Result};

     

       
18
       
18
       
 
       
use dbus::{

     

       
19
       
19
       
 
       
    blocking::{stdintf::org_freedesktop_dbus::Properties, LocalConnection, Proxy},

     

       
20
       
20
       
-
       
    channel::Sender,

     

       
21
       
21
       
-
       
    strings::{BusName, Interface, Member},

     

       
22
       
20
       
 
       
    Message,

     

       
23
       
21
       
 
       
};

     

       
24
       
22
       
 
       
use glob::glob;

     
···

       
34
       
32
       
 
       
use regex::Regex;

     

       
35
       
33
       
 
       
use syslog::Facility;

     

       
36
       
34
       
 
       


     

       
37
       
37
       
-
       
mod fdo_dbus {

     

       
38
       
38
       
-
       
    #![allow(non_upper_case_globals)]

     

       
39
       
39
       
-
       
    #![allow(non_camel_case_types)]

     

       
40
       
40
       
-
       
    #![allow(non_snake_case)]

     

       
41
       
41
       
-
       
    #![allow(unused)]

     

       
42
       
42
       
-
       
    #![allow(clippy::all)]

     

       
43
       
43
       
-
       
    include!(concat!(env!("OUT_DIR"), "/fdo_dbus.rs"));

     

       
44
       
44
       
-
       
}

     

       
45
       
45
       
-
       


     

       
46
       
35
       
 
       
mod systemd_manager {

     

       
47
       
36
       
 
       
    #![allow(non_upper_case_globals)]

     

       
48
       
37
       
 
       
    #![allow(non_camel_case_types)]

     
···

       
61
       
50
       
 
       
    include!(concat!(env!("OUT_DIR"), "/logind_manager.rs"));

     

       
62
       
51
       
 
       
}

     

       
63
       
52
       
 
       


     

       
64
       
64
       
-
       
use crate::{

     

       
65
       
65
       
-
       
    fdo_dbus::OrgFreedesktopDBusNameOwnerChanged, systemd_manager::OrgFreedesktopSystemd1Manager,

     

       
66
       
66
       
-
       
};

     

       
53
       
53
       
+
       
use crate::systemd_manager::OrgFreedesktopSystemd1Manager;

     

       
67
       
54
       
 
       
use crate::{

     

       
68
       
55
       
 
       
    logind_manager::OrgFreedesktopLogin1Manager,

     

       
69
       
56
       
 
       
    systemd_manager::{

     
···

       
907
       
894
       
 
       
    }

     

       
908
       
895
       
 
       
}

     

       
909
       
896
       
 
       


     

       
910
       
910
       
-
       
fn fdo_dbus_proxy(conn: &LocalConnection) -> Proxy<'_, &LocalConnection> {

     

       
911
       
911
       
-
       
    conn.with_proxy(

     

       
912
       
912
       
-
       
        "org.freedesktop.DBus",

     

       
913
       
913
       
-
       
        "/org/freedesktop/DBus",

     

       
914
       
914
       
-
       
        Duration::from_millis(500),

     

       
915
       
915
       
-
       
    )

     

       
916
       
916
       
-
       
}

     

       
917
       
917
       
-
       


     

       
918
       
897
       
 
       
fn systemd1_proxy(conn: &LocalConnection) -> Proxy<'_, &LocalConnection> {

     

       
919
       
898
       
 
       
    conn.with_proxy(

     

       
920
       
899
       
 
       
        "org.freedesktop.systemd1",

     
···

       
951
       
930
       
 
       
    }

     

       
952
       
931
       
 
       
}

     

       
953
       
932
       
 
       


     

       
954
       
954
       
-
       
fn reexecute_systemd_manager(

     

       
955
       
955
       
-
       
    dbus_conn: &LocalConnection,

     

       
956
       
956
       
-
       
    fdo_dbus: &Proxy<'_, &LocalConnection>,

     

       
957
       
957
       
-
       
) -> anyhow::Result<()> {

     

       
958
       
958
       
-
       
    let reexecute_done = Rc::new(RefCell::new(false));

     

       
959
       
959
       
-
       
    let _reexecute_done = reexecute_done.clone();

     

       
960
       
960
       
-
       
    let owner_changed_token = fdo_dbus

     

       
961
       
961
       
-
       
        .match_signal(

     

       
962
       
962
       
-
       
            move |signal: OrgFreedesktopDBusNameOwnerChanged, _: &LocalConnection, _: &Message| {

     

       
963
       
963
       
-
       
                if signal.name.as_str() == "org.freedesktop.systemd1" {

     

       
964
       
964
       
-
       
                    *_reexecute_done.borrow_mut() = true;

     

       
965
       
965
       
-
       
                }

     

       
966
       
966
       
-
       


     

       
967
       
967
       
-
       
                true

     

       
968
       
968
       
-
       
            },

     

       
969
       
969
       
-
       
        )

     

       
970
       
970
       
-
       
        .context("Failed to add signal match for DBus name owner changes")?;

     

       
971
       
971
       
-
       


     

       
972
       
972
       
-
       
    let bus_name = BusName::from("org.freedesktop.systemd1");

     

       
973
       
973
       
-
       
    let object_path = dbus::Path::from("/org/freedesktop/systemd1");

     

       
974
       
974
       
-
       
    let interface = Interface::new("org.freedesktop.systemd1.Manager")

     

       
975
       
975
       
-
       
        .expect("the org.freedesktop.systemd1.Manager interface name should be valid");

     

       
976
       
976
       
-
       
    let method_name = Member::new("Reexecute").expect("the Reexecute method name should be valid");

     

       
977
       
977
       
-
       


     

       
978
       
978
       
-
       
    // Systemd does not reply to the Reexecute method.

     

       
979
       
979
       
-
       
    let _serial = dbus_conn

     

       
980
       
980
       
-
       
        .send(Message::method_call(

     

       
981
       
981
       
-
       
            &bus_name,

     

       
982
       
982
       
-
       
            &object_path,

     

       
983
       
983
       
-
       
            &interface,

     

       
984
       
984
       
-
       
            &method_name,

     

       
985
       
985
       
-
       
        ))

     

       
986
       
986
       
-
       
        .map_err(|_err| anyhow!("Failed to send org.freedesktop.systemd1.Manager.Reexecute"))?;

     

       
987
       
987
       
-
       


     

       
988
       
988
       
-
       
    log::debug!("waiting for systemd to finish reexecuting");

     

       
989
       
989
       
-
       
    while !*reexecute_done.borrow() {

     

       
990
       
990
       
-
       
        _ = dbus_conn

     

       
991
       
991
       
-
       
            .process(Duration::from_secs(500))

     

       
992
       
992
       
-
       
            .context("Failed to process dbus messages")?;

     

       
993
       
993
       
-
       
    }

     

       
994
       
994
       
-
       


     

       
995
       
995
       
-
       
    dbus_conn

     

       
996
       
996
       
-
       
        .remove_match(owner_changed_token)

     

       
997
       
997
       
-
       
        .context("Failed to remove jobs token")?;

     

       
998
       
998
       
-
       


     

       
999
       
999
       
-
       
    Ok(())

     

       
1000
       
1000
       
-
       
}

     

       
1001
       
1001
       
-
       


     

       
1002
       
933
       
 
       
/// Performs switch-to-configuration functionality for a single non-root user

     

       
1003
       
934
       
 
       
fn do_user_switch(parent_exe: String) -> anyhow::Result<()> {

     

       
1004
       
935
       
 
       
    if Path::new(&parent_exe)

     
···

       
1014
       
945
       
 
       
    }

     

       
1015
       
946
       
 
       


     

       
1016
       
947
       
 
       
    let dbus_conn = LocalConnection::new_session().context("Failed to open dbus connection")?;

     

       
1017
       
1017
       
-
       
    let fdo_dbus = fdo_dbus_proxy(&dbus_conn);

     

       
1018
       
948
       
 
       
    let systemd = systemd1_proxy(&dbus_conn);

     

       
1019
       
1019
       
-
       


     

       
1020
       
1020
       
-
       
    reexecute_systemd_manager(&dbus_conn, &fdo_dbus)?;

     

       
1021
       
949
       
 
       


     

       
1022
       
950
       
 
       
    let nixos_activation_done = Rc::new(RefCell::new(false));

     

       
1023
       
951
       
 
       
    let _nixos_activation_done = nixos_activation_done.clone();

     
···

       
1034
       
962
       
 
       
            },

     

       
1035
       
963
       
 
       
        )

     

       
1036
       
964
       
 
       
        .context("Failed to add signal match for systemd removed jobs")?;

     

       
965
       
965
       
+
       


     

       
966
       
966
       
+
       
    // The systemd user session seems to not send a Reloaded signal, so we don't have anything to

     

       
967
       
967
       
+
       
    // wait on here.

     

       
968
       
968
       
+
       
    _ = systemd.reexecute();

     

       
1037
       
969
       
 
       


     

       
1038
       
970
       
 
       
    systemd

     

       
1039
       
971
       
 
       
        .restart_unit("nixos-activation.service", "replace")

     
···

       
1207
       
1139
       
 
       
    let mut units_to_reload = map_from_list_file(RELOAD_LIST_FILE);

     

       
1208
       
1140
       
 
       


     

       
1209
       
1141
       
 
       
    let dbus_conn = LocalConnection::new_system().context("Failed to open dbus connection")?;

     

       
1210
       
1210
       
-
       
    let fdo_dbus = fdo_dbus_proxy(&dbus_conn);

     

       
1211
       
1142
       
 
       
    let systemd = systemd1_proxy(&dbus_conn);

     

       
1212
       
1143
       
 
       
    let logind = login1_proxy(&dbus_conn);

     

       
1213
       
1144
       
 
       


     
···

       
1733
       
1664
       
 
       
    // just in case the new one has trouble communicating with the running pid 1.

     

       
1734
       
1665
       
 
       
    if restart_systemd {

     

       
1735
       
1666
       
 
       
        eprintln!("restarting systemd...");

     

       
1736
       
1736
       
-
       
        reexecute_systemd_manager(&dbus_conn, &fdo_dbus)?;

     

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

     

       
1737
       
1668
       
 
       


     

       
1738
       
1669
       
 
       
        log::debug!("waiting for systemd restart to finish");

     

       
1739
       
1670
       
 
       
        while !*systemd_reload_status.borrow() {