src/tools/disks/zpool_status.rs

   1 use std::mem::{replace, take};
   2
   3 use anyhow::{bail, Error};
   4 use serde::{Deserialize, Serialize};
   5 use serde_json::{Map, Value};
   6
   7 use pbs_tools::nom::{
   8     multispace0, multispace1, notspace1, parse_complete, parse_error, parse_failure, parse_u64,
   9     IResult,
  10 };
  11
  12 use nom::{
  13     bytes::complete::{tag, take_while, take_while1},
  14     character::complete::line_ending,
  15     combinator::opt,
  16     multi::{many0, many1},
  17     sequence::preceded,
  18 };
  19
  20 #[derive(Debug, Serialize, Deserialize)]
  21 pub struct ZFSPoolVDevState {
  22     pub name: String,
  23     pub lvl: u64,
  24     #[serde(skip_serializing_if = "Option::is_none")]
  25     pub state: Option<String>,
  26     #[serde(skip_serializing_if = "Option::is_none")]
  27     pub read: Option<u64>,
  28     #[serde(skip_serializing_if = "Option::is_none")]
  29     pub write: Option<u64>,
  30     #[serde(skip_serializing_if = "Option::is_none")]
  31     pub cksum: Option<u64>,
  32     #[serde(skip_serializing_if = "Option::is_none")]
  33     pub msg: Option<String>,
  34 }
  35
  36 fn expand_tab_length(input: &str) -> usize {
  37     input.chars().map(|c| if c == '\t' { 8 } else { 1 }).sum()
  38 }
  39
  40 fn parse_zpool_status_vdev(i: &str) -> IResult<&str, ZFSPoolVDevState> {
  41     let (n, indent) = multispace0(i)?;
  42
  43     let indent_len = expand_tab_length(indent);
  44
  45     if (indent_len & 1) != 0 {
  46         return Err(parse_failure(n, "wrong indent length"));
  47     }
  48     let i = n;
  49
  50     let indent_level = (indent_len as u64) / 2;
  51
  52     let (i, vdev_name) = notspace1(i)?;
  53
  54     if let Ok((n, _)) = preceded(multispace0, line_ending)(i) {
  55         // special device
  56         let vdev = ZFSPoolVDevState {
  57             name: vdev_name.to_string(),
  58             lvl: indent_level,
  59             state: None,
  60             read: None,
  61             write: None,
  62             cksum: None,
  63             msg: None,
  64         };
  65         return Ok((n, vdev));
  66     }
  67
  68     let (i, state) = preceded(multispace1, notspace1)(i)?;
  69     if let Ok((n, _)) = preceded(multispace0, line_ending)(i) {
  70         // spares
  71         let vdev = ZFSPoolVDevState {
  72             name: vdev_name.to_string(),
  73             lvl: indent_level,
  74             state: Some(state.to_string()),
  75             read: None,
  76             write: None,
  77             cksum: None,
  78             msg: None,
  79         };
  80         return Ok((n, vdev));
  81     }
  82
  83     let (i, read) = preceded(multispace1, parse_u64)(i)?;
  84     let (i, write) = preceded(multispace1, parse_u64)(i)?;
  85     let (i, cksum) = preceded(multispace1, parse_u64)(i)?;
  86     let (i, msg) = opt(preceded(multispace1, take_while(|c| c != '\n')))(i)?;
  87     let (i, _) = line_ending(i)?;
  88
  89     let vdev = ZFSPoolVDevState {
  90         name: vdev_name.to_string(),
  91         lvl: indent_level,
  92         state: Some(state.to_string()),
  93         read: Some(read),
  94         write: Some(write),
  95         cksum: Some(cksum),
  96         msg: msg.map(String::from),
  97     };
  98
  99     Ok((i, vdev))
 100 }
 101
 102 fn parse_zpool_status_tree(i: &str) -> IResult<&str, Vec<ZFSPoolVDevState>> {
 103     // skip header
 104     let (i, _) = tag("NAME")(i)?;
 105     let (i, _) = multispace1(i)?;
 106     let (i, _) = tag("STATE")(i)?;
 107     let (i, _) = multispace1(i)?;
 108     let (i, _) = tag("READ")(i)?;
 109     let (i, _) = multispace1(i)?;
 110     let (i, _) = tag("WRITE")(i)?;
 111     let (i, _) = multispace1(i)?;
 112     let (i, _) = tag("CKSUM")(i)?;
 113     let (i, _) = line_ending(i)?;
 114
 115     // parse vdev list
 116     many1(parse_zpool_status_vdev)(i)
 117 }
 118
 119 fn space_indented_line(indent: usize) -> impl Fn(&str) -> IResult<&str, &str> {
 120     move |i| {
 121         let mut len = 0;
 122         let mut n = i;
 123         loop {
 124             if n.starts_with('\t') {
 125                 len += 8;
 126             } else if n.starts_with(' ') {
 127                 len += 1;
 128             } else {
 129                 break;
 130             }
 131             n = &n[1..];
 132             if len >= indent {
 133                 break;
 134             }
 135         }
 136         if len != indent {
 137             return Err(parse_error(i, "not correctly indented"));
 138         }
 139
 140         take_while1(|c| c != '\n')(n)
 141     }
 142 }
 143
 144 fn parse_zpool_status_field(i: &str) -> IResult<&str, (String, String)> {
 145     let (i, prefix) = take_while1(|c| c != ':')(i)?;
 146     let (i, _) = tag(":")(i)?;
 147     let (i, mut value) = take_while(|c| c != '\n')(i)?;
 148     if value.starts_with(' ') {
 149         value = &value[1..];
 150     }
 151
 152     let (mut i, _) = line_ending(i)?;
 153
 154     let field = prefix.trim().to_string();
 155
 156     let prefix_len = expand_tab_length(prefix);
 157
 158     let indent: usize = prefix_len + 2;
 159
 160     let parse_continuation = opt(space_indented_line(indent));
 161
 162     let mut value = value.to_string();
 163
 164     if field == "config" {
 165         let (n, _) = line_ending(i)?;
 166         i = n;
 167     }
 168
 169     loop {
 170         let (n, cont) = parse_continuation(i)?;
 171
 172         if let Some(cont) = cont {
 173             let (n, _) = line_ending(n)?;
 174             i = n;
 175             if !value.is_empty() {
 176                 value.push('\n');
 177             }
 178             value.push_str(cont);
 179         } else {
 180             if field == "config" {
 181                 let (n, _) = line_ending(i)?;
 182                 value.push('\n');
 183                 i = n;
 184             }
 185             break;
 186         }
 187     }
 188
 189     Ok((i, (field, value)))
 190 }
 191
 192 pub fn parse_zpool_status_config_tree(i: &str) -> Result<Vec<ZFSPoolVDevState>, Error> {
 193     parse_complete("zfs status config tree", i, parse_zpool_status_tree)
 194 }
 195
 196 fn parse_zpool_status(input: &str) -> Result<Vec<(String, String)>, Error> {
 197     parse_complete("zfs status output", input, many0(parse_zpool_status_field))
 198 }
 199
 200 pub fn vdev_list_to_tree(vdev_list: &[ZFSPoolVDevState]) -> Result<Value, Error> {
 201     indented_list_to_tree(vdev_list, |vdev| {
 202         let node = serde_json::to_value(vdev).unwrap();
 203         (node, vdev.lvl)
 204     })
 205 }
 206
 207 fn indented_list_to_tree<'a, T, F, I>(items: I, to_node: F) -> Result<Value, Error>
 208 where
 209     T: 'a,
 210     I: IntoIterator<Item = &'a T>,
 211     F: Fn(&T) -> (Value, u64),
 212 {
 213     struct StackItem {
 214         node: Map<String, Value>,
 215         level: u64,
 216         children_of_parent: Vec<Value>,
 217     }
 218
 219     let mut stack = Vec::<StackItem>::new();
 220     // hold current node and the children of the current parent (as that's where we insert)
 221     let mut cur = StackItem {
 222         node: Map::<String, Value>::new(),
 223         level: 0,
 224         children_of_parent: Vec::new(),
 225     };
 226
 227     for item in items {
 228         let (node, node_level) = to_node(item);
 229         let vdev_level = 1 + node_level;
 230         let mut node = match node {
 231             Value::Object(map) => map,
 232             _ => bail!("to_node returned wrong type"),
 233         };
 234
 235         node.insert("leaf".to_string(), Value::Bool(true));
 236
 237         // if required, go back up (possibly multiple levels):
 238         while vdev_level < cur.level {
 239             cur.children_of_parent.push(Value::Object(cur.node));
 240             let mut parent = stack.pop().unwrap();
 241             parent
 242                 .node
 243                 .insert("children".to_string(), Value::Array(cur.children_of_parent));
 244             parent.node.insert("leaf".to_string(), Value::Bool(false));
 245             cur = parent;
 246
 247             if vdev_level > cur.level {
 248                 // when we encounter misimatching levels like "0, 2, 1" instead of "0, 1, 2, 1"
 249                 bail!("broken indentation between levels");
 250             }
 251         }
 252
 253         if vdev_level > cur.level {
 254             // indented further, push our current state and start a new "map"
 255             stack.push(StackItem {
 256                 node: replace(&mut cur.node, node),
 257                 level: replace(&mut cur.level, vdev_level),
 258                 children_of_parent: take(&mut cur.children_of_parent),
 259             });
 260         } else {
 261             // same indentation level, add to children of the previous level:
 262             cur.children_of_parent
 263                 .push(Value::Object(replace(&mut cur.node, node)));
 264         }
 265     }
 266
 267     while !stack.is_empty() {
 268         cur.children_of_parent.push(Value::Object(cur.node));
 269         let mut parent = stack.pop().unwrap();
 270         parent
 271             .node
 272             .insert("children".to_string(), Value::Array(cur.children_of_parent));
 273         parent.node.insert("leaf".to_string(), Value::Bool(false));
 274         cur = parent;
 275     }
 276
 277     Ok(Value::Object(cur.node))
 278 }
 279
 280 #[test]
 281 fn test_vdev_list_to_tree() {
 282     const DEFAULT: ZFSPoolVDevState = ZFSPoolVDevState {
 283         name: String::new(),
 284         lvl: 0,
 285         state: None,
 286         read: None,
 287         write: None,
 288         cksum: None,
 289         msg: None,
 290     };
 291
 292     #[rustfmt::skip]
 293     let input = vec![
 294         //ZFSPoolVDevState { name: "root".to_string(), lvl: 0, ..DEFAULT },
 295         ZFSPoolVDevState { name: "vdev1".to_string(), lvl: 1, ..DEFAULT },
 296         ZFSPoolVDevState { name: "vdev1-disk1".to_string(), lvl: 2, ..DEFAULT },
 297         ZFSPoolVDevState { name: "vdev1-disk2".to_string(), lvl: 2, ..DEFAULT },
 298         ZFSPoolVDevState { name: "vdev2".to_string(), lvl: 1, ..DEFAULT },
 299         ZFSPoolVDevState { name: "vdev2-g1".to_string(), lvl: 2, ..DEFAULT },
 300         ZFSPoolVDevState { name: "vdev2-g1-d1".to_string(), lvl: 3, ..DEFAULT },
 301         ZFSPoolVDevState { name: "vdev2-g1-d2".to_string(), lvl: 3, ..DEFAULT },
 302         ZFSPoolVDevState { name: "vdev2-g2".to_string(), lvl: 2, ..DEFAULT },
 303         ZFSPoolVDevState { name: "vdev3".to_string(), lvl: 1, ..DEFAULT },
 304         ZFSPoolVDevState { name: "vdev4".to_string(), lvl: 1, ..DEFAULT },
 305         ZFSPoolVDevState { name: "vdev4-g1".to_string(), lvl: 2, ..DEFAULT },
 306         ZFSPoolVDevState { name: "vdev4-g1-d1".to_string(), lvl: 3, ..DEFAULT },
 307         ZFSPoolVDevState { name: "vdev4-g1-d1-x1".to_string(), lvl: 4, ..DEFAULT },
 308         ZFSPoolVDevState { name: "vdev4-g2".to_string(), lvl: 2, ..DEFAULT }, // up by 2
 309     ];
 310
 311     const EXPECTED: &str = "{\
 312         \"children\":[{\
 313             \"children\":[{\
 314                 \"leaf\":true,\
 315                 \"lvl\":2,\"name\":\"vdev1-disk1\"\
 316             },{\
 317                 \"leaf\":true,\
 318                 \"lvl\":2,\"name\":\"vdev1-disk2\"\
 319             }],\
 320             \"leaf\":false,\
 321             \"lvl\":1,\"name\":\"vdev1\"\
 322         },{\
 323             \"children\":[{\
 324                 \"children\":[{\
 325                     \"leaf\":true,\
 326                     \"lvl\":3,\"name\":\"vdev2-g1-d1\"\
 327                 },{\
 328                     \"leaf\":true,\
 329                     \"lvl\":3,\"name\":\"vdev2-g1-d2\"\
 330                 }],\
 331                 \"leaf\":false,\
 332                 \"lvl\":2,\"name\":\"vdev2-g1\"\
 333             },{\
 334                 \"leaf\":true,\
 335                 \"lvl\":2,\"name\":\"vdev2-g2\"\
 336             }],\
 337             \"leaf\":false,\
 338             \"lvl\":1,\"name\":\"vdev2\"\
 339         },{\
 340             \"leaf\":true,\
 341             \"lvl\":1,\"name\":\"vdev3\"\
 342         },{\
 343             \"children\":[{\
 344                 \"children\":[{\
 345                     \"children\":[{\
 346                         \"leaf\":true,\
 347                         \"lvl\":4,\"name\":\"vdev4-g1-d1-x1\"\
 348                     }],\
 349                     \"leaf\":false,\
 350                     \"lvl\":3,\"name\":\"vdev4-g1-d1\"\
 351                 }],\
 352                 \"leaf\":false,\
 353                 \"lvl\":2,\"name\":\"vdev4-g1\"\
 354             },{\
 355                 \"leaf\":true,\
 356                 \"lvl\":2,\"name\":\"vdev4-g2\"\
 357             }],\
 358             \"leaf\":false,\
 359             \"lvl\":1,\"name\":\"vdev4\"\
 360         }],\
 361         \"leaf\":false\
 362    }";
 363     let expected: Value =
 364         serde_json::from_str(EXPECTED).expect("failed to parse expected json value");
 365
 366     let tree = vdev_list_to_tree(&input).expect("failed to turn valid vdev list into a tree");
 367     assert_eq!(tree, expected);
 368 }
 369
 370 pub fn zpool_status(pool: &str) -> Result<Vec<(String, String)>, Error> {
 371     let mut command = std::process::Command::new("zpool");
 372     command.args(&["status", "-p", "-P", pool]);
 373
 374     let output = proxmox_sys::command::run_command(command, None)?;
 375
 376     parse_zpool_status(&output)
 377 }
 378
 379 #[cfg(test)]
 380 fn test_parse(output: &str) -> Result<(), Error> {
 381     let mut found_config = false;
 382
 383     for (k, v) in parse_zpool_status(output)? {
 384         println!("<{}> => '{}'", k, v);
 385         if k == "config" {
 386             let vdev_list = parse_zpool_status_config_tree(&v)?;
 387             let _tree = vdev_list_to_tree(&vdev_list);
 388             found_config = true;
 389         }
 390     }
 391     if !found_config {
 392         bail!("got zpool status without config key");
 393     }
 394
 395     Ok(())
 396 }
 397
 398 #[test]
 399 fn test_zpool_status_parser() -> Result<(), Error> {
 400     let output = r###"  pool: tank
 401  state: DEGRADED
 402 status: One or more devices could not be opened.  Sufficient replicas exist for
 403         the pool to continue functioning in a degraded state.
 404 action: Attach the missing device and online it using 'zpool online'.
 405    see: http://www.sun.com/msg/ZFS-8000-2Q
 406  scrub: none requested
 407 config:
 408
 409         NAME        STATE     READ WRITE CKSUM
 410         tank        DEGRADED     0     0     0
 411           mirror-0  DEGRADED     0     0     0
 412             c1t0d0  ONLINE       0     0     0
 413             c1t2d0  ONLINE       0     0     0
 414             c1t1d0  UNAVAIL      0     0     0  cannot open
 415           mirror-1  DEGRADED     0     0     0
 416         tank1       DEGRADED     0     0     0
 417         tank2       DEGRADED     0     0     0
 418
 419 errors: No known data errors
 420 "###;
 421
 422     test_parse(output)
 423 }
 424
 425 #[test]
 426 fn test_zpool_status_parser2() -> Result<(), Error> {
 427     // Note: this input create TABS
 428     let output = r###"  pool: btest
 429  state: ONLINE
 430   scan: none requested
 431 config:
 432
 433         NAME           STATE     READ WRITE CKSUM
 434         btest          ONLINE       0     0     0
 435           mirror-0     ONLINE       0     0     0
 436             /dev/sda1  ONLINE       0     0     0
 437             /dev/sda2  ONLINE       0     0     0
 438           mirror-1     ONLINE       0     0     0
 439             /dev/sda3  ONLINE       0     0     0
 440             /dev/sda4  ONLINE       0     0     0
 441         logs
 442           /dev/sda5    ONLINE       0     0     0
 443
 444 errors: No known data errors
 445 "###;
 446     test_parse(output)
 447 }
 448
 449 #[test]
 450 fn test_zpool_status_parser3() -> Result<(), Error> {
 451     let output = r###"  pool: bt-est
 452  state: ONLINE
 453   scan: none requested
 454 config:
 455
 456         NAME           STATE     READ WRITE CKSUM
 457         bt-est          ONLINE       0     0     0
 458           mirror-0     ONLINE       0     0     0
 459             /dev/sda1  ONLINE       0     0     0
 460             /dev/sda2  ONLINE       0     0     0
 461           mirror-1     ONLINE       0     0     0
 462             /dev/sda3  ONLINE       0     0     0
 463             /dev/sda4  ONLINE       0     0     0
 464         logs
 465           /dev/sda5    ONLINE       0     0     0
 466
 467 errors: No known data errors
 468 "###;
 469
 470     test_parse(output)
 471 }
 472
 473 #[test]
 474 fn test_zpool_status_parser_spares() -> Result<(), Error> {
 475     let output = r###"  pool: tank
 476  state: ONLINE
 477   scan: none requested
 478 config:
 479
 480         NAME           STATE     READ WRITE CKSUM
 481         tank          ONLINE       0     0     0
 482           mirror-0     ONLINE       0     0     0
 483             /dev/sda1  ONLINE       0     0     0
 484             /dev/sda2  ONLINE       0     0     0
 485           mirror-1     ONLINE       0     0     0
 486             /dev/sda3  ONLINE       0     0     0
 487             /dev/sda4  ONLINE       0     0     0
 488         logs
 489           /dev/sda5    ONLINE       0     0     0
 490         spares
 491           /dev/sdb     AVAIL
 492           /dev/sdc     AVAIL
 493
 494 errors: No known data errors
 495 "###;
 496
 497     test_parse(output)
 498 }