Selecione blocos de linhas entre $blockBEGIN e $blockEND contendo um padrão específico

parece que seus "blocos" são delimitados por "linhas vazias", por isso é muito fácil de usar awkpara filtrá-los:

awk -F'\n' -v RS='' '$1 ~ /^ID/ && $NF ~ /^Sector Size/ && /: Ready/' pdisks-simplified-20230825.log

Premissas:

• os blocos são separados por uma linha em branco (como na pergunta original do OP)
• todos os blocos começam IDe terminam com Sector Size(caso contrário, precisaremos adicionar um pouco mais de lógica)

Se awkfor uma solução aceitável:

awk -v myptn="${myPATTERN}" 'BEGIN {RS=""} $0 ~ myptn' block.log

Onde:

• -v myptn="${myPATTERN}"- preencha a awkvariável nomeada myptncom o valor da variável bash/OS
• RS=""- definir separador de registro como linha em branco
• $0 ~ myptn- se o registro contiver a string/padrão contido na awkvariável nomeada myptn, imprima o registro [ NOTA: isso corresponderá a qualquer string dentro do bloco, portanto, se o OP precisar ser mais específico, precisaremos expandir o código]
• block.logcontém ambos os blocos de amostra fornecidos pelo OP

Quando myPATTERN="Ready"isso gera:

ID                              : 0:1:4
Status                          : Ok
State                           : Ready
Power Status                    : Spun Up
Bus Protocol                    : SAS
Media                           : HDD
Capacity                        : 3,725.50 GB (4000225165312 bytes)
Vendor ID                       : DELL(tm)
Product ID                      : ST4000NM0023
Serial No.                      : Z1Z6AAR9
Part Number                     : TH0529FG212334AI01AGA02
Sector Size                     : 512B

Outra abordagem baseada em strings que delimitam o início/fim de um bloco:

awk -v bstart="${blockBEGIN}" -v bend="${blockEND}" -v myptn="${myPATTERN}" '

index($0,bstart)==1 { inblock = 1 }                              # if line starts with "bstart" then enable flag
index($0,bend)==1   { if (block ~ myptn)                         # if line starts with "bend" then ...
                         print block                             # print current block and ...
                      block=""                                   # reset our
                      inblock=0                                  # varables
                    }

inblock             { block = block (block ? ORS : "" ) $0 }     # if flag is set then append current line to variable "block"
' block.log

NOTAS:

• assume bstarte bendcomeça no primeiro caractere da linha, caso contrário, substitua as index()chamadas por um apropriado para corresponder bstartebend
• assume bstarte bendé único o suficiente para corresponder apenas a uma linha em um bloco

Isso gera:

ID                              : 0:1:4
Status                          : Ok
State                           : Ready
Power Status                    : Spun Up
Bus Protocol                    : SAS
Media                           : HDD
Capacity                        : 3,725.50 GB (4000225165312 bytes)
Vendor ID                       : DELL(tm)
Product ID                      : ST4000NM0023
Serial No.                      : Z1Z6AAR9
Part Number                     : TH0529FG212334AI01AGA02

Com o GNU awk para limites de vários caracteres RS, RTe \>palavras, isso pode ser o que você está tentando fazer:

$ awk -v beg="$blockBEGIN" -v mid="$myPATTERN" -v end="$blockEND"  '
    BEGIN { RS = "\n" end "\\>[^\n]*" }
    sub("(^|.*\n)"beg"\\>",beg) && ($0~mid) { print $0 RT }
' file
ID                              : 0:1:4
Status                          : Ok
State                           : Ready
Power Status                    : Spun Up
Bus Protocol                    : SAS
Media                           : HDD
Capacity                        : 3,725.50 GB (4000225165312 bytes)
Vendor ID                       : DELL(tm)
Product ID                      : ST4000NM0023
Serial No.                      : Z1Z6AAR9
Part Number                     : TH0529FG212334AI01AGA02
Sector Size                     : 512B

Perl pode ser mais adequado para este caso de uso, que não precisa de linhas em branco como separador:

perl -0777 -ne '
  $blockBEGIN="ID";
  $blockEND="Sector Size";
  $myPATTERN="Ready";
  while (/^$blockBEGIN.*?$blockEND[^\n]+/gms) {
    $block=$&;
    print "$block\n" if ($block =~ /$myPATTERN/);
  }
' input.file

Supondo que não haja quebra de linha entre os blocos, você pode dividir o arquivo em blocos com base em um regex e depois analisá-lo em pares chave/valor.

Ruby ou Perl serão os melhores para fazer isso.

Aqui está um rubi:

ruby -e '$<.read.split(/^(?<!\A)(?=ID\s)/).each{|blk|
    kv=blk.split(/\R/).map{|line| line.split(/\s+:\s+/)}.to_h
    puts blk if kv["State"]=="Ready" 
}' file

Ou você pode usar uma abordagem de bloco com qualquer awk:

awk '
BEGIN{cnt=0}
{blk[cnt]=blk[cnt] ? blk[cnt] ORS $0 : $0}
    FNR>1 && /^ID /{cnt++}
END{for(i=0; i<=cnt; i++) 
    if (blk[i]~/State[[:space:]]+:[[:space:]]+Ready/) print blk[i]}
' file

Ou,

awk '
/^ID[[:space:]]/ {
    if (s~/State[[:space:]]+:[[:space:]]+Ready/) print s 
    s=$0 ORS
    next
}    
{s=s $0 ORS}
' file  

Imprime o bloco correspondente:

ID                              : 0:1:4
Status                          : Ok
State                           : Ready
Power Status                    : Spun Up
Bus Protocol                    : SAS
Media                           : HDD
Capacity                        : 3,725.50 GB (4000225165312 bytes)
Vendor ID                       : DELL(tm)
Product ID                      : ST4000NM0023
Serial No.                      : Z1Z6AAR9
Part Number                     : TH0529FG212334AI01AGA02
Sector Size                     : 512B