OpenGnsys  1.1.1
Disk.lib
Ir a la documentación de este archivo.
1 #!/bin/bash
2 #
12 # Función ficticia para lanzar parted con timeout, evitando cuelgues del programa.
13 function parted ()
14 {
15 timeout -k 5s -s KILL 3s $(which parted) "$@"
16 }
17 
18 
19 # ##
47 function ogCreatePartitions ()
48 {
49 # Variables locales.
50 local ND DISK PTTYPE PART SECTORS START SIZE TYPE CACHEPART IODISCO IOSIZE CACHESIZE
51 local EXTSTART EXTSIZE NVME_PREFIX tmpsfdisk
52 # Si se solicita, mostrar ayuda.
53 if [ "$*" == "help" ]; then
54  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk str_parttype:int_partsize ..." \
55  "$FUNCNAME 1 NTFS:10000000 EXT3:5000000 LINUX-SWAP:1000000"
56  return
57 fi
58 # Error si no se reciben al menos 2 parámetros.
59 [ $# -ge 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?
60 
61 # Nº total de sectores, para evitar desbordamiento (evitar redondeo).
62 ND="$1"
63 DISK=$(ogDiskToDev "$ND") || return $?
64 PTTYPE=$(ogGetPartitionTableType $1)
65 PTTYPE=${PTTYPE:-"MSDOS"} # Por defecto para discos vacíos.
66 case "$PTTYPE" in
67  GPT) ogCreateGptPartitions "$@"
68  return $? ;;
69  MSDOS) ;;
70  *) ogRaiseError $OG_ERR_PARTITION "$PTTYPE"
71  return $? ;;
72 esac
73 SECTORS=$(ogGetLastSector $1)
74 # Se recalcula el nº de sectores del disco 1, si existe partición de caché.
75 CACHEPART=$(ogFindCache 2>/dev/null)
76 [ "$ND" = "${CACHEPART% *}" ] && CACHESIZE=$(ogGetCacheSize 2>/dev/null | awk '{print $0*2}')
77 
78 # Sector de inicio (la partición 1 empieza en el sector 63).
79 IODISCO=$(ogDiskToDev $1)
80 IOSIZE=$(fdisk -l $IODISCO | awk '/I\/O/ {print $4}')
81 if [ "$IOSIZE" == "4096" ]; then
82  START=4096
83  SECTORS=$[SECTORS-8192]
84  [ -n "$CACHESIZE" ] && SECTORS=$[SECTORS-CACHESIZE+2048-(SECTORS-CACHESIZE)%2048-1]
85 else
86  START=63
87  [ -n "$CACHESIZE" ] && SECTORS=$[SECTORS-CACHESIZE]
88 fi
89 PART=1
90 
91 # Fichero temporal de entrada para "sfdisk"
92 tmpsfdisk=/tmp/sfdisk$$
93 trap "rm -f $tmpsfdisk" 1 2 3 9 15
94 
95 echo "unit: sectors" >$tmpsfdisk
96 echo >>$tmpsfdisk
97 
98 NVME_PREFIX=""
99 if [[ $DISK == *"nvme"* ]]; then
100  NVME_PREFIX="p"
101 fi
102 
103 
104 # Generar fichero de entrada para "sfdisk" con las particiones.
105 shift
106 while [ $# -gt 0 ]; do
107  # Conservar los datos de la partición de caché.
108  if [ "$ND $PART" == "$CACHEPART" -a -n "$CACHESIZE" ]; then
109  echo "$DISK$NVME_PREFIX$PART : start=$[SECTORS+1], size=$CACHESIZE, Id=ca" >>$tmpsfdisk
110  PART=$[PART+1]
111  fi
112  # Leer formato de cada parámetro - Tipo:Tamaño
113  TYPE="${1%%:*}"
114  SIZE="${1#*:}"
115  # Obtener identificador de tipo de partición válido.
116  ID=$(ogTypeToId "$TYPE" MSDOS)
117  [ "$TYPE" != "CACHE" -a -n "$ID" ] || ogRaiseError $OG_ERR_PARTITION "$TYPE" || return $?
118  # Comprobar tamaño numérico y convertir en sectores de 512 B.
119  [[ "$SIZE" == *([0-9]) ]] || ogRaiseError $OG_ERR_FORMAT "$SIZE" || return $?
120  SIZE=$[SIZE*2]
121  # Comprobar si la partición es extendida.
122  if [ $ID = 5 ]; then
123  [ $PART -le 4 ] || ogRaiseError $OG_ERR_FORMAT || return $?
124  # El inicio de la primera partición logica es el de la extendida más 4x512
125  let EXTSTART=$START+2048
126  let EXTSIZE=$SIZE-2048
127  fi
128  # Incluir particiones lógicas dentro de la partición extendida.
129  if [ $PART = 5 ]; then
130  [ -n "$EXTSTART" ] || ogRaiseError $OG_ERR_FORMAT || return $?
131  START=$EXTSTART
132  SECTORS=$[EXTSTART+EXTSIZE]
133  fi
134  # Generar datos para la partición.
135  echo "$DISK$NVME_PREFIX$PART : start=$START, size=$SIZE, Id=$ID" >>$tmpsfdisk
136  # Error si se supera el nº total de sectores.
137  START=$[START+SIZE]
138  if [ "$IOSIZE" == "4096" -a $PART -gt 4 ]; then
139  START=$[START+2048]
140  fi
141  [ $START -le $SECTORS ] || ogRaiseError $OG_ERR_FORMAT "$[START/2] > $[SECTORS/2]" || return $?
142  PART=$[PART+1]
143  shift
144 done
145 # Si no se indican las 4 particiones primarias, definirlas como vacías, conservando la partición de caché.
146 while [ $PART -le 4 ]; do
147  if [ "$ND $PART" == "$CACHEPART" -a -n "$CACHESIZE" ]; then
148  echo "$DISK$NVME_PREFIX$PART : start=$[SECTORS+1], size=$CACHESIZE, Id=ca" >>$tmpsfdisk
149  else
150  echo "$DISK$NVME_PREFIX$PART : start=0, size=0, Id=0" >>$tmpsfdisk
151  fi
152  PART=$[PART+1]
153 done
154 # Si se define partición extendida sin lógicas, crear particion 5 vacía.
155 if [ $PART = 5 -a -n "$EXTSTART" ]; then
156  echo "${DISK}5 : start=$EXTSTART, size=$EXTSIZE, Id=0" >>$tmpsfdisk
157 fi
158 
159 # Desmontar los sistemas de archivos del disco antes de realizar las operaciones.
160 ogUnmountAll $ND 2>/dev/null
161 [ -n "$CACHESIZE" ] && ogUnmountCache 2>/dev/null
162 
163 # Si la tabla de particiones no es valida, volver a generarla.
164 ogCreatePartitionTable $ND
165 # Definir particiones y notificar al kernel.
166 sfdisk -f $DISK < $tmpsfdisk 2>/dev/null && partprobe $DISK
167 rm -f $tmpsfdisk
168 [ -n "$CACHESIZE" ] && ogMountCache 2>/dev/null || return 0
169 }
170 
171 
172 # ##
191 function ogCreateGptPartitions ()
192 {
193 # Variables locales.
194 local ND DISK PART SECTORS ALIGN START SIZE TYPE CACHEPART CACHESIZE DELOPTIONS OPTIONS
195 # Si se solicita, mostrar ayuda.
196 if [ "$*" == "help" ]; then
197  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk str_parttype:int_partsize ..." \
198  "$FUNCNAME 1 NTFS:10000000 EXT3:5000000 LINUX-SWAP:1000000"
199  return
200 fi
201 # Error si no se reciben menos de 2 parámetros.
202 [ $# -ge 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?
203 
204 # Nº total de sectores, para evitar desbordamiento (evitar redondeo).
205 ND="$1"
206 DISK=$(ogDiskToDev "$ND") || return $?
207 # Se calcula el ultimo sector del disco (total de sectores usables)
208 SECTORS=$(ogGetLastSector $1)
209 # Se recalcula el nº de sectores del disco si existe partición de caché.
210 CACHEPART=$(ogFindCache 2>/dev/null)
211 [ "$ND" = "${CACHEPART% *}" ] && CACHESIZE=$(ogGetCacheSize 2>/dev/null | awk '{print $0*2}')
212 [ -n "$CACHESIZE" ] && SECTORS=$[SECTORS-CACHESIZE]
213 # Si el disco es GPT empieza en el sector 2048 por defecto, pero podria cambiarse
214 ALIGN=$(sgdisk -D $DISK 2>/dev/null)
215 START=$ALIGN
216 PART=1
217 
218 # Leer parámetros con definición de particionado.
219 shift
220 
221 while [ $# -gt 0 ]; do
222  # Si PART es la cache, nos la saltamos y seguimos con el siguiente numero para conservar los datos de la partición de caché.
223  if [ "$ND $PART" == "$CACHEPART" -a -n "$CACHESIZE" ]; then
224  PART=$[PART+1]
225  fi
226  # Leer formato de cada parámetro - Tipo:Tamaño
227  TYPE="${1%%:*}"
228  SIZE="${1#*:}"
229  # Error si la partición es extendida (no válida en discos GPT).
230  if [ "$TYPE" == "EXTENDED" ]; then
231  ogRaiseError $OG_ERR_PARTITION "EXTENDED"
232  return $?
233  fi
234  # Comprobar si existe la particion actual, capturamos su tamaño para ver si cambio o no
235  PARTSIZE=$(ogGetPartitionSize $ND $PART 2>/dev/null)
236  # En sgdisk no se pueden redimensionar las particiones, es necesario borrarlas y volver a crealas
237  [ $PARTSIZE ] && DELOPTIONS="$DELOPTIONS -d$PART"
238  # Creamos la particion
239  # Obtener identificador de tipo de partición válido.
240  ID=$(ogTypeToId "$TYPE" GPT)
241  [ "$TYPE" != "CACHE" -a -n "$ID" ] || ogRaiseError $OG_ERR_PARTITION "$TYPE" || return $?
242  # Comprobar tamaño numérico y convertir en sectores de 512 B.
243  [[ "$SIZE" == *([0-9]) ]] || ogRaiseError $OG_ERR_FORMAT "$SIZE" || return $?
244  SIZE=$[SIZE*2]
245  # SIZE debe ser múltiplo de ALIGN, si no gdisk lo mueve automáticamente.
246  DIV=$[$SIZE/$ALIGN]
247  SIZE=$[$DIV*$ALIGN]
248  # En el caso de que la partición sea EMPTY no se crea nada
249  if [ "$TYPE" != "EMPTY" ]; then
250  OPTIONS="$OPTIONS -n$PART:$START:+$SIZE -t$PART:$ID "
251  fi
252  START=$[START+SIZE]
253  # Error si se supera el nº total de sectores.
254  [ $START -le $SECTORS ] || ogRaiseError $OG_ERR_FORMAT "$[START/2] > $[SECTORS/2]" || return $?
255  PART=$[PART+1]
256  shift
257 done
258 
259 # Desmontar los sistemas de archivos del disco antes de realizar las operaciones.
260 ogUnmountAll $ND 2>/dev/null
261 [ -n "$CACHESIZE" ] && ogUnmountCache 2>/dev/null
262 
263 # Si la tabla de particiones no es valida, volver a generarla.
264 ogCreatePartitionTable $ND
265 # Definir particiones y notificar al kernel.
266 # Borramos primero las particiones y luego creamos las nuevas
267 sgdisk $DELOPTIONS $OPTIONS $DISK 2>/dev/null && partprobe $DISK
268 [ -n "$CACHESIZE" ] && ogMountCache 2>/dev/null || return 0
269 }
270 
271 
272 # ##
289 function ogCreatePartitionTable ()
290 {
291 # Variables locales.
292 local DISK PTTYPE CREATE CREATEPTT
293 
294 # Si se solicita, mostrar ayuda.
295 if [ "$*" == "help" ]; then
296  ogHelp "$FUNCNAME int_ndisk [str_partype]" \
297  "$FUNCNAME 1 GPT" "$FUNCNAME 1"
298  return
299 fi
300 # Error si no se reciben 1 o 2 parámetros.
301 case $# in
302  1) CREATEPTT="" ;;
303  2) CREATEPTT="$2" ;;
304  *) ogRaiseError $OG_ERR_FORMAT
305  return $? ;;
306 esac
307 
308 # Capturamos el tipo de tabla de particiones actual
309 DISK=$(ogDiskToDev $1) || return $?
310 PTTYPE=$(ogGetPartitionTableType $1)
311 PTTYPE=${PTTYPE:-"MSDOS"} # Por defecto para discos vacíos.
312 CREATEPTT=${CREATEPTT:-"$PTTYPE"}
313 
314 # Si la tabla actual y la que se indica son iguales, se comprueba si hay que regenerarla.
315 if [ "$CREATEPTT" == "$PTTYPE" ]; then
316  case "$PTTYPE" in
317  GPT) [ ! $(sgdisk -p $DISK 2>&1 >/dev/null) ] || CREATE="GPT" ;;
318  MSDOS) [ $(parted -s $DISK print >/dev/null) ] || CREATE="MSDOS" ;;
319  esac
320 else
321  CREATE="$CREATEPTT"
322 fi
323 # Dependiendo del valor de CREATE, creamos la tabla de particiones en cada caso.
324 case "$CREATE" in
325  GPT)
326  # Si es necesario crear una tabla GPT pero la actual es MSDOS
327  if [ "$PTTYPE" == "MSDOS" ]; then
328  sgdisk -go $DISK
329  else
330  echo -e "2\nw\nY\n" | gdisk $DISK
331  fi
332  partprobe $DISK 2>/dev/null
333  ;;
334  MSDOS)
335  # Si es necesario crear una tabla MSDOS pero la actual es GPT
336  if [ "$PTTYPE" == "GPT" ]; then
337  sgdisk -Z $DISK
338  fi
339  # Crear y borrar una partición para que la tabla se genere bien.
340  echo -e "o\nn\np\n\n\n\nd\n\nw" | fdisk $DISK
341  partprobe $DISK 2>/dev/null
342  ;;
343 esac
344 }
345 
346 
347 # ##
359 function ogDeletePartitionTable ()
360 {
361 # Variables locales.
362 local DISK
363 
364 # Si se solicita, mostrar ayuda.
365 if [ "$*" == "help" ]; then
366  ogHelp "$FUNCNAME int_ndisk" "$FUNCNAME 1"
367  return
368 fi
369 # Error si no se reciben 1 parámetros.
370 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
371 
372 # Obteniendo Identificador linux del disco.
373 DISK=$(ogDiskToDev $1) || return $?
374 # Crear una tabla de particiones vacía.
375 case "$(ogGetPartitionTableType $1)" in
376  GPT) sgdisk -o $DISK ;;
377  MSDOS) echo -ne "o\nw" | fdisk $DISK ;;
378 esac
379 }
380 
381 
382 # ##
403 function ogDevToDisk ()
404 {
405 # Variables locales.
406 local CACHEFILE DEV PART NVME_PREFIX d n
407 # Si se solicita, mostrar ayuda.
408 if [ "$*" == "help" ]; then
409  ogHelp "$FUNCNAME" "$FUNCNAME path_device | LABEL=str_label | UUID=str_uuid" \
410  "$FUNCNAME /dev/sda => 1" \
411  "$FUNCNAME /dev/sda1 => 1 1" \
412  "$FUNCNAME LABEL=CACHE => 1 4"
413  return
414 fi
415 
416 # Error si no se recibe 1 parámetro.
417 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
418 
419 # Obtener dispositivo a partir de camino, etiqueta o UUID.
420 DEV="$1"
421 case "$DEV" in
422  LABEL=*) DEV=$(blkid -L "${1#*=}") ;;
423  PARTLABEL=*) DEV=$(realpath "/dev/disk/by-partlabel/${1#*=}" 2>/dev/null) ;;
424  PARTUUID=*) DEV=$(realpath "/dev/disk/by-partuuid/${1#*=}" 2>/dev/null) ;;
425  UUID=*) DEV=$(blkid -U "${1#*=}") ;;
426 esac
427 
428 # Error si no es fichero de bloques o directorio (para LVM).
429 [ -b "$DEV" -o -d "$DEV" ] || ogRaiseError $OG_ERR_NOTFOUND "$1" || return $?
430 
431 # Buscar en fichero de caché de discos.
432 CACHEFILE=/var/cache/disks.cfg
433 PART=$(awk -F: -v d="$DEV" '{if ($2==d) {print $1}}' $CACHEFILE 2>/dev/null)
434 if [ -n "$PART" ]; then
435  echo "$PART"
436  return
437 fi
438 # Si no se encuentra, procesa todos los discos para devolver su nº de orden y de partición.
439 n=1
440 for d in $(ogDiskToDev); do
441 NVME_PREFIX=""
442 if [[ $d == *"nvme"* ]]; then
443  NVME_PREFIX="p"
444 fi
445 
446 
447  [ -n "$(echo $DEV | grep $d)" ] && echo "$n ${DEV#$d$NVME_PREFIX}" && return
448  n=$[n+1]
449 done
450 ogRaiseError $OG_ERR_NOTFOUND "$1"
451 return $OG_ERR_NOTFOUND
452 }
453 
454 
455 # ##
484 function ogDiskToDev ()
485 {
486 # Variables locales
487 local CACHEFILE ALLDISKS MPATH VOLGROUPS ZFSVOLS DISK PART ZPOOL i
488 
489 # Si se solicita, mostrar ayuda.
490 if [ "$*" == "help" ]; then
491  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk [int_npartition]" \
492  "$FUNCNAME => /dev/sda /dev/sdb" \
493  "$FUNCNAME 1 => /dev/sda" \
494  "$FUNCNAME 1 1 => /dev/sda1"
495  return
496 fi
497 
498 # Borrar fichero de caché de configuración si hay cambios en las particiones.
499 CACHEFILE=/var/cache/disks.cfg
500 if ! diff -q <(cat /proc/partitions) /tmp/.partitions &>/dev/null; then
501  # Guardar copia de las particiones definidas para comprobar cambios.
502  cp -a /proc/partitions /tmp/.partitions
503  rm -f $CACHEFILE
504 fi
505 
506 # Si existe una correspondencia con disco/dispositivo en el caché; mostrarlo y salir.
507 PART=$(awk -F: -v d="$*" '{if ($1==d) {print $2}}' $CACHEFILE 2>/dev/null)
508 if [ -n "$PART" ]; then
509  echo "$PART"
510  return
511 fi
512 
513 # Continuar para detectar nuevos dispositivos.
514 # Listar dispositivos de discos.
515 ALLDISKS=$((lsblk -n -e 1,2 -x MAJ:MIN 2>/dev/null || lsblk -n -e 1,2) | \
516  awk '$6~/^disk$/ {gsub(/!/,"/"); printf "/dev/%s ",$1}')
517 #ALLDISKS=$(lsblk -Jdp | jq -r '.blockdevices[] | select(.type=="disk").name')
518 # Listar volúmenes lógicos.
519 VOLGROUPS=$(vgs -a --noheadings 2>/dev/null | awk '{printf "/dev/%s ",$1}')
520 ALLDISKS="$ALLDISKS $VOLGROUPS"
521 
522 # Detectar caminos múltiples (ignorar mensaje si no está configurado Multipath).
523 if MPATH=$(multipath -l -v 1 2>/dev/null | awk '{printf "/dev/mapper/%s ",$1}'; exit ${PIPESTATUS[0]}); then
524  # Quitar de la lista los discos que forman parte de Multipath.
525  for i in $(multipath -ll | awk '$6=="ready" {printf "/dev/%s ",$3}'); do
526  ALLDISKS="${ALLDISKS//$i/}"
527  done
528  # Añadir caminos múltiples a los discos detectados.
529  ALLDISKS="$ALLDISKS $MPATH"
530 fi
531 
532 # Detectar volúmenes ZFS.
533 ZFSVOLS=$(blkid | awk -F: '/zfs/ {print $1}')
534 ALLDISKS="$ALLDISKS $ZFSVOLS"
535 
536 # Mostrar salidas segun el número de parametros.
537 case $# in
538  0) # Muestra todos los discos, separados por espacios.
539  echo $ALLDISKS
540  ;;
541  1) # Error si el parámetro no es un número positivo.
542  [[ "$1" =~ ^[1-9][0-9]*$ ]] || ogRaiseError $OG_ERR_FORMAT "$1" || return $?
543  DISK=$(echo "$ALLDISKS" | awk -v n=$1 '{print $n}')
544  # Error si el fichero no existe.
545  [ -e "$DISK" ] || ogRaiseError $OG_ERR_NOTFOUND "$1" || return $?
546  # Actualizar caché de configuración y mostrar dispositivo.
547  echo "$*:$DISK" >> $CACHEFILE
548  echo "$DISK"
549  ;;
550  2) # Error si los 2 parámetros no son números positivos.
551  [[ "$1" =~ ^[1-9][0-9]*$ ]] && [[ "$2" =~ ^[1-9][0-9]*$ ]] || ogRaiseError $OG_ERR_FORMAT "$1 $2" || return $?
552  DISK=$(echo "$ALLDISKS" | awk -v n=$1 '{print $n}')
553  [ -e "$DISK" ] || ogRaiseError $OG_ERR_NOTFOUND "$1" || return $?
554  PART="$DISK$2"
555  # Comprobar si es partición.
556  if [ -b "$PART" ]; then
557  # Actualizar caché de configuración y mostrar dispositivo.
558  echo "$*:$PART" >> $CACHEFILE
559  echo "$PART"
560  else
561  # Comprobar si RAID o Multipath (tener en cuenta enlace simbólico).
562  PART="${DISK}p$2"
563  if [ "$(stat -L -c "%A" "$PART" 2>/dev/null | cut -c1)" == "b" ]; then
564  # Actualizar caché de configuración y mostrar dispositivo.
565  echo "$*:$PART" >> $CACHEFILE
566  echo "$PART"
567  else
568  PART=""
569  # Comprobar si volumen lógico. /* (comentario Doxygen)
570  if ogCheckStringInGroup "$DISK" "$VOLGROUPS"; then
571  PART=$(lvscan -a 2>/dev/null | \
572  awk -F\' -v n=$2 "\$2~/^${DISK//\//\\/}\// {if (NR==n) print \$2}")
573  [ -e "$PART" ] || ogRaiseError $OG_ERR_NOTFOUND "$1 $2" || return $?
574  # (comentario Doxygen) */
575  fi
576  # Comprobar si volumen ZFS que puede ser montado.
577  if ogCheckStringInGroup "$DISK" "$ZFSVOLS"; then
578  zpool import -f -R /mnt -N -a 2>/dev/null
579  ZPOOL=$(blkid -s LABEL -o value $DISK)
580  PART=$(zfs list -Hp -o name,canmount,mountpoint -r $ZPOOL | \
581  awk -v n=$2 '$2=="on" && $3!="none" {c++; if (c==n) print $1}')
582  fi
583  # Salir si no se encuentra dispositivo.
584  [ -n "$PART" ] || ogRaiseError $OG_ERR_NOTFOUND "$1 $2" || return $?
585  # Devolver camino al dispositivo.
586  # Actualizar caché de configuración y mostrar dispositivo.
587  echo "$*:$PART" >> $CACHEFILE
588  echo "$PART"
589  fi
590  fi
591  ;;
592  *) # Formato erroneo.
593  ogRaiseError $OG_ERR_FORMAT
594  return $OG_ERR_FORMAT
595  ;;
596 esac
597 }
598 
599 
600 # ##
615 function ogGetDiskSize ()
616 {
617 # Variables locales.
618 local DISK SIZE
619 
620 # Si se solicita, mostrar ayuda.
621 if [ "$*" == "help" ]; then
622  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" "$FUNCNAME 1 => 244198584"
623  return
624 fi
625 # Error si no se recibe 1 parámetro.
626 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
627 
628 # Obtener el tamaño del disco.
629 DISK="$(ogDiskToDev $1)" || return $?
630 SIZE=$(awk -v D=${DISK#/dev/} '{if ($4==D) {print $3}}' /proc/partitions)
631 # Si no, obtener tamaño del grupo de volúmenes.
632 [ -z "$SIZE" ] && SIZE=$(vgs --noheadings --units=B -o dev_size $DISK 2>/dev/null | \
633  awk '{print $1/1024}')
634 
635 # Mostrar salida.
636 [ -n "$SIZE" ] && echo "$SIZE"
637 }
638 
639 
640 # ##
651 function ogGetDiskType ()
652 {
653 # Variables locales
654 local DEV MAJOR TYPE
655 
656 # Si se solicita, mostrar ayuda.
657 if [ "$*" == "help" ]; then
658  ogHelp "$FUNCNAME" "$FUNCNAME path_device" \
659  "$FUNCNAME /dev/sdb => USB"
660  return
661 fi
662 # Error si no se recibe 1 parámetro.
663 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
664 
665 # Obtener el driver del dispositivo de bloques.
666 [ -b "$1" ] || ogRaiseError $OG_ERR_NOTFOUND "$1" || return $?
667 DEV=${1#/dev/}
668 MAJOR=$(awk -v D="$DEV" '{if ($4==D) print $1;}' /proc/partitions)
669 TYPE=$(awk -v D=$MAJOR '/Block/ {bl=1} {if ($1==D&&bl) print toupper($2)}' /proc/devices)
670 # Devolver mnemónico del driver de dispositivo.
671 case "$TYPE" in
672  SD)
673  TYPE="DISK"
674  udevadm info -q property $1 2>/dev/null | grep -q "^ID_BUS=usb" && TYPE="USB"
675  ;;
676  BLKEXT)
677  TYPE="NVM"
678  ;;
679  SR|IDE*)
680  TYPE="CDROM" # FIXME Comprobar discos IDE.
681  ;;
682  MD|CCISS*)
683  TYPE="RAID"
684  ;;
685  DEVICE-MAPPER)
686  TYPE="MAPPER" # FIXME Comprobar LVM y RAID.
687  ;;
688 esac
689 echo $TYPE
690 }
691 
692 
693 # ##
697 function ogGetEsp ()
698 {
699 local PART d
700 for d in $(blkid -o device|sort); do
701  # Previene error para /dev/loop0
702  PART="$(ogDevToDisk $d 2>/dev/null)" || continue
703  # En discos NVMe blkid devuelve una salida del tipo:
704  # >/dev/loop0
705  # >/dev/nvme0n1
706  # >/dev/nvme0n1p1
707  # al analizar la particion nvme0n1, PART solo tiene un argumento y hace que ogGetPartitionId lance un error
708  LEN=$(echo $PART | awk '{ print length($0) }')
709  if [ $LEN -gt 1 ]; then
710  if [ "$(ogGetPartitionId $PART)" == "$(ogTypeToId EFI GPT)" ]; then
711  echo $PART
712  break
713  fi
714  fi
715 done
716 }
717 
718 
719 # ##
735 function ogGetLastSector ()
736 {
737 # Variables locales
738 local DISK PART LASTSECTOR
739 
740 # Si se solicita, mostrar ayuda.
741 if [ "$*" == "help" ]; then
742  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk [int_npart]" \
743  "$FUNCNAME 1 => 488392064" \
744  "$FUNCNAME 1 1 => 102400062"
745  return
746 fi
747 
748 # Obtener último sector.
749 case $# in
750  1) # Para un disco.
751  DISK=$(ogDiskToDev $1) || return $?
752  LASTSECTOR=$(LANG=C sgdisk -p $DISK | awk '/last usable sector/ {print($(NF))}')
753  ;;
754  2) # Para una partición.
755  DISK=$(ogDiskToDev $1) || return $?
756  PART=$(ogDiskToDev $1 $2) || return $?
757  LASTSECTOR=$(LANG=C sgdisk -p $DISK | awk -v P="$2" '{if ($1==P) print $3}')
758  ;;
759  *) # Error si se reciben más parámetros.
760  ogRaiseError $OG_ERR_FORMAT
761  return $? ;;
762 esac
763 echo $LASTSECTOR
764 }
765 
766 
767 # ##
780 function ogGetPartitionActive ()
781 {
782 # Variables locales
783 local DISK
784 
785 # Si se solicita, mostrar ayuda.
786 if [ "$*" == "help" ]; then
787  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" "$FUNCNAME 1 => 1"
788  return
789 fi
790 # Error si no se recibe 1 parámetro.
791 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
792 
793 # Comprobar que el disco existe y listar su partición activa.
794 DISK="$(ogDiskToDev $1)" || return $?
795 LANG=C parted -sm $DISK print 2>/dev/null | awk -F: '$7~/boot/ {print $1}'
796 }
797 
798 
799 # ##
821 function ogGetPartitionId ()
822 {
823 # Variables locales.
824 local DISK ID
825 
826 # Si se solicita, mostrar ayuda.
827 if [ "$*" == "help" ]; then
828  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition" \
829  "$FUNCNAME 1 1 => 7"
830  return
831 fi
832 # Error si no se reciben 2 parámetros.
833 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?
834 
835 # Detectar y mostrar el id. de tipo de partición.
836 DISK=$(ogDiskToDev $1) || return $?
837 case "$(ogGetPartitionTableType $1)" in
838  GPT) ID=$(sgdisk -p $DISK 2>/dev/null | awk -v p="$2" '{if ($1==p) print $6;}') || ogRaiseError $OG_ERR_NOTFOUND "$1,$2" || return $?
839  [ "$ID" == "8300" -a "$1 $2" == "$(ogFindCache)" ] && ID=CA00
840  ;;
841  MSDOS) ID=$(sfdisk --id $DISK $2 2>/dev/null) || ogRaiseError $OG_ERR_NOTFOUND "$1,$2" || return $? ;;
842  LVM) ID=10000 ;;
843  ZPOOL) ID=10010 ;;
844 esac
845 echo $ID
846 }
847 
848 
849 # ##
868 function ogGetPartitionSize ()
869 {
870 # Variables locales.
871 local PART SIZE
872 
873 # Si se solicita, mostrar ayuda.
874 if [ "$*" == "help" ]; then
875  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition" \
876  "$FUNCNAME 1 1 => 10000000"
877  return
878 fi
879 # Error si no se reciben 2 parámetros.
880 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?
881 
882 # Devolver tamaño de partición, del volumen lógico o del sistema de archivos (para ZFS).
883 PART="$(ogDiskToDev $1 $2)" || return $?
884 SIZE=$(partx -gbo SIZE $PART 2>/dev/null | awk '{print int($1/1024)}')
885 [ -z "$SIZE" ] && SIZE=$(lvs --noheadings -o lv_size --units k $PART | awk '{printf "%d",$0}')
886 [ -z "$SIZE" ] && SIZE=$(ogGetFsSize $1 $2)
887 echo ${SIZE:-0}
888 }
889 
890 
891 # ##
915 function ogGetPartitionsNumber ()
916 {
917 # Variables locales.
918 local DISK
919 # Si se solicita, mostrar ayuda.
920 if [ "$*" == "help" ]; then
921  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" \
922  "$FUNCNAME 1 => 3"
923  return
924 fi
925 # Error si no se recibe 1 parámetro.
926 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
927 
928 # Contar el nº de veces que aparece el disco en su lista de particiones.
929 DISK=$(ogDiskToDev $1) 2>/dev/null
930 case "$(ogGetPartitionTableType $1)" in
931  GPT|MSDOS)
932  partx -gso NR $DISK 2>/dev/null | awk -v p=0 '{p=$1} END {print p}' ;;
933  LVM) lvs --noheadings $DISK 2>/dev/null | wc -l ;;
934  ZPOOL) zpool list &>/dev/null || modprobe zfs
935  zpool import -f -R /mnt -N -a 2>/dev/null
936  zfs list -Hp -o name,canmount,mountpoint -r $(blkid -s LABEL -o value $DISK) | \
937  awk '$2=="on" && $3!="none" {c++}
938  END {print c}'
939  ;;
940 esac
941 }
942 
943 
944 # ##
962 function ogGetPartitionTableType ()
963 {
964 # Variables locales.
965 local DISK TYPE
966 
967 # Si se solicita, mostrar ayuda.
968 if [ "$*" == "help" ]; then
969  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" \
970  "$FUNCNAME 1 => MSDOS"
971  return
972 fi
973 # Error si no se recibe 1 parámetro.
974 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
975 
976 # Sustituye n de disco por su dispositivo.
977 DISK=$(ogDiskToDev $1) || return $?
978 
979 # Comprobar tabla de particiones.
980 if [ -b $DISK ]; then
981  TYPE=$(parted -sm $DISK print 2>/dev/null | awk -F: -v D=$DISK '{ if($1 == D) print toupper($6)}')
982  [ -z "$TYPE" ] && TYPE=$(parted -sm $DISK print 2>/dev/null | awk -F: -v D=$DISK '{ if($1 == D) print toupper($6)}')
983 fi
984 # Comprobar si es volumen lógico.
985 [ -d $DISK ] && vgs $DISK &>/dev/null && TYPE="LVM"
986 # Comprobar si es pool de ZFS.
987 [ -z "$TYPE" -o "$TYPE" == "UNKNOWN" ] && [ -n "$(blkid -s TYPE $DISK | grep zfs)" ] && TYPE="ZPOOL"
988 
989 # Mostrar salida.
990 [ -n "$TYPE" ] && echo "$TYPE"
991 }
992 
993 
994 # ##
1016 function ogGetPartitionType ()
1017 {
1018 # Variables locales.
1019 local ID TYPE
1020 
1021 # Si se solicita, mostrar ayuda.
1022 if [ "$*" == "help" ]; then
1023  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition" \
1024  "$FUNCNAME 1 1 => NTFS"
1025  return
1026 fi
1027 # Error si no se reciben 2 parámetros.
1028 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1029 
1030 # Detectar id. de tipo de partición y codificar al mnemonico.
1031 ID=$(ogGetPartitionId "$1" "$2") || return $?
1032 TYPE=$(ogIdToType "$ID")
1033 echo "$TYPE"
1034 }
1035 
1036 
1037 # ##
1053 function ogHidePartition ()
1054 {
1055 # Variables locales.
1056 local PART TYPE NEWTYPE
1057 # Si se solicita, mostrar ayuda.
1058 if [ "$*" == "help" ]; then
1059  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition" \
1060  "$FUNCNAME 1 1"
1061  return
1062 fi
1063 # Error si no se reciben 2 parámetros.
1064 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1065 PART=$(ogDiskToDev "$1" "$2") || return $?
1066 
1067 # Obtener tipo de partición.
1068 TYPE=$(ogGetPartitionType "$1" "$2")
1069 case "$TYPE" in
1070  NTFS) NEWTYPE="HNTFS" ;;
1071  FAT32) NEWTYPE="HFAT32" ;;
1072  FAT16) NEWTYPE="HFAT16" ;;
1073  FAT12) NEWTYPE="HFAT12" ;;
1074  WINDOWS)NEWTYPE="WIN-RESERV";;
1075  *) ogRaiseError $OG_ERR_PARTITION "$TYPE"
1076  return $? ;;
1077 esac
1078 # Cambiar tipo de partición.
1079 ogSetPartitionType $1 $2 $NEWTYPE
1080 }
1081 
1082 
1083 # ##
1093 function ogIdToType ()
1094 {
1095 # Variables locales
1096 local ID TYPE
1097 
1098 # Si se solicita, mostrar ayuda.
1099 if [ "$*" == "help" ]; then
1100  ogHelp "$FUNCNAME" "$FUNCNAME int_idpart" \
1101  "$FUNCNAME 83 => LINUX"
1102  return
1103 fi
1104 # Error si no se recibe 1 parámetro.
1105 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1106 
1107 # Obtener valor hexadecimal de 4 caracteres rellenado con 0 por delante.
1108 ID=$(printf "%4s" "$1" | tr ' ' '0')
1109 case "${ID,,}" in
1110  0000) TYPE="EMPTY" ;;
1111  0001) TYPE="FAT12" ;;
1112  0005|000f) TYPE="EXTENDED" ;;
1113  0006|000e) TYPE="FAT16" ;;
1114  0007) TYPE="NTFS" ;;
1115  000b|000c) TYPE="FAT32" ;;
1116  0011) TYPE="HFAT12" ;;
1117  0012) TYPE="COMPAQDIAG" ;;
1118  0016|001e) TYPE="HFAT16" ;;
1119  0017) TYPE="HNTFS" ;;
1120  001b|001c) TYPE="HFAT32" ;;
1121  0042) TYPE="WIN-DYNAMIC" ;;
1122  0082|8200) TYPE="LINUX-SWAP" ;;
1123  0083|8300) TYPE="LINUX" ;;
1124  008e|8E00) TYPE="LINUX-LVM" ;;
1125  00a5|a503) TYPE="FREEBSD" ;;
1126  00a6) TYPE="OPENBSD" ;;
1127  00a7) TYPE="CACHE" ;; # (compatibilidad con Brutalix)
1128  00af|af00) TYPE="HFS" ;;
1129  00be|be00) TYPE="SOLARIS-BOOT" ;;
1130  00bf|bf0[0145]) TYPE="SOLARIS" ;;
1131  00ca|ca00) TYPE="CACHE" ;;
1132  00da) TYPE="DATA" ;;
1133  00ee) TYPE="GPT" ;;
1134  00ef|ef00) TYPE="EFI" ;;
1135  00fb) TYPE="VMFS" ;;
1136  00fd|fd00) TYPE="LINUX-RAID" ;;
1137  0700) TYPE="WINDOWS" ;;
1138  0c01) TYPE="WIN-RESERV" ;;
1139  7f00) TYPE="CHROMEOS-KRN" ;;
1140  7f01) TYPE="CHROMEOS" ;;
1141  7f02) TYPE="CHROMEOS-RESERV" ;;
1142  8301) TYPE="LINUX-RESERV" ;;
1143  a500) TYPE="FREEBSD-DISK" ;;
1144  a501) TYPE="FREEBSD-BOOT" ;;
1145  a502) TYPE="FREEBSD-SWAP" ;;
1146  ab00) TYPE="HFS-BOOT" ;;
1147  af01) TYPE="HFS-RAID" ;;
1148  bf02) TYPE="SOLARIS-SWAP" ;;
1149  bf03) TYPE="SOLARIS-DISK" ;;
1150  ef01) TYPE="MBR" ;;
1151  ef02) TYPE="BIOS-BOOT" ;;
1152  10000) TYPE="LVM-LV" ;;
1153  10010) TYPE="ZFS-VOL" ;;
1154  *) TYPE="UNKNOWN" ;;
1155 esac
1156 echo "$TYPE"
1157 }
1158 
1159 
1160 # ogIsDiskLocked int_ndisk
1161 #@brief Comprueba si un disco está bloqueado por una operación de uso exclusivo.
1162 #@param int_ndisk nº de orden del disco
1163 #@return Código de salida: 0 - bloqueado, 1 - sin bloquear o error.
1164 #@note Los ficheros de bloqueo se localizan en \c /var/lock/dev, siendo \c dev el dispositivo de la partición o de su disco, sustituyendo el carácter "/" por "-".
1165 #@version 1.1.0 - Primera versión para OpenGnsys.
1166 #@author Ramon Gomez, ETSII Universidad de Sevilla
1167 #@date 2016-04-08
1168 #*/ ##
1169 function ogIsDiskLocked ()
1170 {
1171 # Variables locales
1172 local DISK LOCKFILE
1173 
1174 # Si se solicita, mostrar ayuda.
1175 if [ "$*" == "help" ]; then
1176  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" \
1177  "if $FUNCNAME 1; then ... ; fi"
1178  return
1179 fi
1180 # Falso, en caso de error.
1181 [ $# == 1 ] || return 1
1182 DISK="$(ogDiskToDev $1 2>/dev/null)" || return 1
1183 
1184 # Comprobar existencia de fichero de bloqueo para el disco.
1185 LOCKFILE="/var/lock/lock${DISK//\//-}"
1186 test -f $LOCKFILE
1187 }
1188 
1189 
1190 # ##
1204 function ogListPartitions ()
1205 {
1206 # Variables locales.
1207 local DISK PART NPARTS TYPE SIZE
1208 
1209 # Si se solicita, mostrar ayuda.
1210 if [ "$*" == "help" ]; then
1211  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" \
1212  "$FUNCNAME 1 => NTFS:10000000 EXT3:5000000 LINUX-SWAP:1000000"
1213  return
1214 fi
1215 # Error si no se recibe 1 parámetro.
1216 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT "$FORMAT" || return $?
1217 
1218 # Procesar la salida de \c parted .
1219 DISK="$(ogDiskToDev $1)" || return $?
1220 NPARTS=$(ogGetPartitionsNumber $1)
1221 for (( PART = 1; PART <= NPARTS; PART++ )); do
1222  TYPE=$(ogGetPartitionType $1 $PART 2>/dev/null); TYPE=${TYPE:-EMPTY}
1223  SIZE=$(ogGetPartitionSize $1 $PART 2>/dev/null); SIZE=${SIZE:-0}
1224  echo -n "$TYPE:$SIZE "
1225 done
1226 echo
1227 }
1228 
1229 
1230 # ##
1236 function ogListPrimaryPartitions ()
1237 {
1238 # Variables locales.
1239 local PTTYPE PARTS
1240 
1241 # Si se solicita, mostrar ayuda.
1242 if [ "$*" == "help" ]; then
1243  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" \
1244  "$FUNCNAME 1 => NTFS:10000000 EXT3:5000000 EXTENDED:1000000"
1245  return
1246 fi
1247 
1248 PTTYPE=$(ogGetPartitionTableType $1) || return $?
1249 PARTS=$(ogListPartitions "$@") || return $?
1250 case "$PTTYPE" in
1251  GPT) echo $PARTS | sed 's/\( EMPTY:0\)*$//' ;;
1252  MSDOS) echo $PARTS | cut -sf1-4 -d" " | sed 's/\( EMPTY:0\)*$//' ;;
1253 esac
1254 }
1255 
1256 
1257 # ##
1263 function ogListLogicalPartitions ()
1264 {
1265 # Variables locales.
1266 local PTTYPE PARTS
1267 
1268 # Si se solicita, mostrar ayuda.
1269 if [ "$*" == "help" ]; then
1270  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" \
1271  "$FUNCNAME 1 => LINUX-SWAP:999998"
1272  return
1273 fi
1274 PTTYPE=$(ogGetPartitionTableType $1) || return $?
1275 [ "$PTTYPE" == "MSDOS" ] || ogRaiseError $OG_ERR_PARTITION "" || return $?
1276 PARTS=$(ogListPartitions "$@") || return $?
1277 echo $PARTS | cut -sf5- -d" "
1278 }
1279 
1280 
1281 # ##
1293 function ogLockDisk ()
1294 {
1295 # Variables locales
1296 local DISK LOCKFILE
1297 
1298 # Si se solicita, mostrar ayuda.
1299 if [ "$*" == "help" ]; then
1300  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" \
1301  "$FUNCNAME 1"
1302  return
1303 fi
1304 # Error si no se recibe 1 parámetro.
1305 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1306 
1307 # Obtener partición.
1308 DISK="$(ogDiskToDev $1)" || return $?
1309 
1310 # Crear archivo de bloqueo exclusivo.
1311 LOCKFILE="/var/lock/lock${DISK//\//-}"
1312 touch $LOCKFILE
1313 }
1314 
1315 
1316 # ##
1332 function ogSetPartitionActive ()
1333 {
1334 # Variables locales
1335 local DISK PART
1336 
1337 # Si se solicita, mostrar ayuda.
1338 if [ "$*" == "help" ]; then
1339  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition" \
1340  "$FUNCNAME 1 1"
1341  return
1342 fi
1343 
1344 # Si el EFI esta activo me salgo.
1345 ogIsEfiActive && ogEcho session log warning "EFI: $MSG_DONTUSE $FUNCNAME" && return
1346 
1347 # Error si no se reciben 2 parámetros.
1348 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1349 
1350 # Comprobar que el disco existe y activar la partición indicada.
1351 DISK="$(ogDiskToDev $1)" || return $?
1352 PART="$(ogDiskToDev $1 $2)" || return $?
1353 parted -s $DISK set $2 boot on 2>/dev/null
1354 }
1355 
1356 
1357 # ##
1379 function ogSetPartitionId ()
1380 {
1381 # Variables locales
1382 local DISK PART PTTYPE ID
1383 
1384 # Si se solicita, mostrar ayuda.
1385 if [ "$*" == "help" ]; then
1386  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition hex_partid" \
1387  "$FUNCNAME 1 1 7"
1388  return
1389 fi
1390 # Error si no se reciben 3 parámetros.
1391 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1392 
1393 # Sustituye nº de disco y nº partición por su dispositivo.
1394 DISK=$(ogDiskToDev $1) || return $?
1395 PART=$(ogDiskToDev $1 $2) || return $?
1396 # Error si el id. de partición no es hexadecimal.
1397 ID="${3^^}"
1398 [[ "$ID" =~ ^[0-9A-F]+$ ]] || ogRaiseError $OG_ERR_OUTOFLIMIT "$3" || return $?
1399 
1400 # Elección del tipo de partición.
1401 PTTYPE=$(ogGetPartitionTableType $1)
1402 case "$PTTYPE" in
1403  GPT) sgdisk -t$2:$ID $DISK 2>/dev/null ;;
1404  MSDOS) sfdisk --id $DISK $2 $ID 2>/dev/null ;;
1405  *) ogRaiseError $OG_ERR_OUTOFLIMIT "$1,$PTTYPE"
1406  return $? ;;
1407 esac
1408 
1409 # MSDOS) Correcto si fdisk sin error o con error pero realiza Syncing
1410 if [ "${PIPESTATUS[1]}" == "0" -o $? -eq 0 ]; then
1411  partprobe $DISK 2>/dev/null
1412  return 0
1413 else
1414  ogRaiseError $OG_ERR_PARTITION "$1,$2,$3"
1415  return $?
1416 fi
1417 }
1418 
1419 
1420 # ##
1435 function ogSetPartitionSize ()
1436 {
1437 # Variables locales.
1438 local DISK PART SIZE
1439 
1440 # Si se solicita, mostrar ayuda.
1441 if [ "$*" == "help" ]; then
1442  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition int_size" \
1443  "$FUNCNAME 1 1 10000000"
1444  return
1445 fi
1446 # Error si no se reciben 3 parámetros.
1447 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1448 
1449 # Obtener el tamaño de la partición.
1450 DISK="$(ogDiskToDev $1)" || return $?
1451 PART="$(ogDiskToDev $1 $2)" || return $?
1452 # Convertir tamaño en KB a sectores de 512 B.
1453 SIZE=$[$3*2] || ogRaiseError $OG_ERR_FORMAT || return $?
1454 # Redefinir el tamaño de la partición.
1455 sfdisk -f -uS -N$2 $DISK <<< ",$SIZE" &>/dev/null || ogRaiseError $OG_ERR_PARTITION "$1,$2" || return $?
1456 partprobe $DISK 2>/dev/null
1457 }
1458 
1459 
1460 # ##
1478 function ogSetPartitionType ()
1479 {
1480 # Variables locales
1481 local DISK PART PTTYPE ID
1482 
1483 # Si se solicita, mostrar ayuda.
1484 if [ "$*" == "help" ]; then
1485  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition str_type" \
1486  "$FUNCNAME 1 1 NTFS"
1487  return
1488 fi
1489 # Error si no se reciben 3 parámetros.
1490 [ $# == 3 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1491 
1492 # Sustituye nº de disco por su dispositivo.
1493 DISK=`ogDiskToDev $1` || return $?
1494 PART=`ogDiskToDev $1 $2` || return $?
1495 
1496 # Elección del tipo de partición.
1497 PTTYPE=$(ogGetPartitionTableType $1)
1498 ID=$(ogTypeToId "$3" "$PTTYPE")
1499 [ -n "$ID" ] || ogRaiseError $OG_ERR_FORMAT "$3,$PTTYPE" || return $?
1500 ogSetPartitionId $1 $2 $ID
1501 }
1502 
1503 
1504 # ##
1522 function ogTypeToId ()
1523 {
1524 # Variables locales
1525 local PTTYPE ID=""
1526 
1527 # Si se solicita, mostrar ayuda.
1528 if [ "$*" == "help" ]; then
1529  ogHelp "$FUNCNAME" "$FUNCNAME str_parttype [str_tabletype]" \
1530  "$FUNCNAME LINUX => 83" \
1531  "$FUNCNAME LINUX MSDOS => 83"
1532  return
1533 fi
1534 # Error si no se reciben 1 o 2 parámetros.
1535 [ $# -lt 1 -o $# -gt 2 ] && (ogRaiseError $OG_ERR_FORMAT; return $?)
1536 
1537 # Asociar id. de partición para su mnemónico.
1538 PTTYPE=${2:-"MSDOS"}
1539 case "$PTTYPE" in
1540  GPT) # Se incluyen mnemónicos compatibles con tablas MSDOS.
1541  case "$1" in
1542  EMPTY) ID=0 ;;
1543  WINDOWS|NTFS|EXFAT|FAT32|FAT16|FAT12|HNTFS|HFAT32|HFAT16|HFAT12)
1544  ID=0700 ;;
1545  WIN-RESERV) ID=0C01 ;;
1546  CHROMEOS-KRN) ID=7F00 ;;
1547  CHROMEOS) ID=7F01 ;;
1548  CHROMEOS-RESERV) ID=7F02 ;;
1549  LINUX-SWAP) ID=8200 ;;
1550  LINUX|EXT[234]|REISERFS|REISER4|XFS|JFS)
1551  ID=8300 ;;
1552  LINUX-RESERV) ID=8301 ;;
1553  LINUX-LVM) ID=8E00 ;;
1554  FREEBSD-DISK) ID=A500 ;;
1555  FREEBSD-BOOT) ID=A501 ;;
1556  FREEBSD-SWAP) ID=A502 ;;
1557  FREEBSD) ID=A503 ;;
1558  HFS-BOOT) ID=AB00 ;;
1559  HFS|HFS+) ID=AF00 ;;
1560  HFSPLUS) ID=AF00 ;;
1561  HFS-RAID) ID=AF01 ;;
1562  SOLARIS-BOOT) ID=BE00 ;;
1563  SOLARIS) ID=BF00 ;;
1564  SOLARIS-SWAP) ID=BF02 ;;
1565  SOLARIS-DISK) ID=BF03 ;;
1566  CACHE) ID=CA00;;
1567  EFI) ID=EF00 ;;
1568  LINUX-RAID) ID=FD00 ;;
1569  esac
1570  ;;
1571  MSDOS)
1572  case "$1" in
1573  EMPTY) ID=0 ;;
1574  FAT12) ID=1 ;;
1575  EXTENDED) ID=5 ;;
1576  FAT16) ID=6 ;;
1577  WINDOWS|NTFS|EXFAT)
1578  ID=7 ;;
1579  FAT32) ID=b ;;
1580  HFAT12) ID=11 ;;
1581  HFAT16) ID=16 ;;
1582  HNTFS) ID=17 ;;
1583  HFAT32) ID=1b ;;
1584  LINUX-SWAP) ID=82 ;;
1585  LINUX|EXT[234]|REISERFS|REISER4|XFS|JFS)
1586  ID=83 ;;
1587  LINUX-LVM) ID=8e ;;
1588  FREEBSD) ID=a5 ;;
1589  OPENBSD) ID=a6 ;;
1590  HFS|HFS+) ID=af ;;
1591  SOLARIS-BOOT) ID=be ;;
1592  SOLARIS) ID=bf ;;
1593  CACHE) ID=ca ;;
1594  DATA) ID=da ;;
1595  GPT) ID=ee ;;
1596  EFI) ID=ef ;;
1597  VMFS) ID=fb ;;
1598  LINUX-RAID) ID=fd ;;
1599  esac
1600  ;;
1601  LVM)
1602  case "$1" in
1603  LVM-LV) ID=10000 ;;
1604  esac
1605  ;;
1606  ZVOL)
1607  case "$1" in
1608  ZFS-VOL) ID=10010 ;;
1609  esac
1610  ;;
1611 esac
1612 echo $ID
1613 }
1614 
1615 
1616 # ##
1632 function ogUnhidePartition ()
1633 {
1634 # Variables locales.
1635 local PART TYPE NEWTYPE
1636 # Si se solicita, mostrar ayuda.
1637 if [ "$*" == "help" ]; then
1638  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk int_npartition" \
1639  "$FUNCNAME 1 1"
1640  return
1641 fi
1642 # Error si no se reciben 2 parámetros.
1643 [ $# == 2 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1644 PART=$(ogDiskToDev "$1" "$2") || return $?
1645 
1646 # Obtener tipo de partición.
1647 TYPE=$(ogGetPartitionType "$1" "$2")
1648 case "$TYPE" in
1649  HNTFS) NEWTYPE="NTFS" ;;
1650  HFAT32) NEWTYPE="FAT32" ;;
1651  HFAT16) NEWTYPE="FAT16" ;;
1652  HFAT12) NEWTYPE="FAT12" ;;
1653  WIN-RESERV) NEWTYPE="WINDOWS" ;;
1654  *) ogRaiseError $OG_ERR_PARTITION "$TYPE"
1655  return $? ;;
1656 esac
1657 # Cambiar tipo de partición.
1658 ogSetPartitionType $1 $2 $NEWTYPE
1659 }
1660 
1661 
1662 # ##
1674 function ogUnlockDisk ()
1675 {
1676 # Variables locales
1677 local DISK LOCKFILE
1678 
1679 # Si se solicita, mostrar ayuda.
1680 if [ "$*" == "help" ]; then
1681  ogHelp "$FUNCNAME" "$FUNCNAME int_ndisk" \
1682  "$FUNCNAME 1"
1683  return
1684 fi
1685 # Error si no se recibe 1 parámetro.
1686 [ $# == 1 ] || ogRaiseError $OG_ERR_FORMAT || return $?
1687 
1688 # Obtener partición.
1689 DISK="$(ogDiskToDev $1)" || return $?
1690 
1691 # Borrar archivo de bloqueo exclusivo.
1692 LOCKFILE="/var/lock/lock${DISK//\//-}"
1693 rm -f $LOCKFILE
1694 }
1695 
1696 
1697 # ##
1708 function ogUpdatePartitionTable ()
1709 {
1710 local i
1711 for i in `ogDiskToDev`
1712 do
1713  partprobe $i
1714 done
1715 }
ogDiskToDev
function ogDiskToDev()
Devuelve la equivalencia entre el nº de orden del dispositivo (dicso o partición) y el nombre de fich...
Definition: Disk.lib:484
ogIsEfiActive
function ogIsEfiActive()
Comprueba si el sistema tiene activo el arranque EFI.
Definition: Inventory.lib:124
ogListLogicalPartitions
function ogListLogicalPartitions()
Metafunción que lista las particiones lógicas de una tabla tipo MSDOS. #.
Definition: Disk.lib:1263
ogSetPartitionId
function ogSetPartitionId()
Cambia el identificador de la partición. #.
Definition: Disk.lib:1379
ogGetPartitionSize
function ogGetPartitionSize()
Muestra el tamano en KB de una particion determinada. #.
Definition: Disk.lib:868
ogIsDiskLocked
function ogIsDiskLocked()
Definition: Disk.lib:1169
ogDevToDisk
function ogDevToDisk()
Devuelve el nº de orden de dicso (y partición) correspondiente al nombre de fichero de dispositivo o ...
Definition: Disk.lib:403
ogGetPartitionId
function ogGetPartitionId()
Devuelve el mnemónico con el tipo de partición. #.
Definition: Disk.lib:821
ogGetDiskType
function ogGetDiskType()
Muestra el tipo de disco (real, RAID, meta-disco, USB, etc.). #.
Definition: Disk.lib:651
ogGetPartitionTableType
function ogGetPartitionTableType()
Devuelve el tipo de tabla de particiones del disco (GPT o MSDOS) #.
Definition: Disk.lib:962
ogRaiseError
function ogRaiseError()
Devuelve el mensaje y el código de error correspondiente. #.
Definition: System.lib:188
ogDeletePartitionTable
function ogDeletePartitionTable()
Borra la tabla de particiones del disco. #.
Definition: Disk.lib:359
ogHelp
function ogHelp()
Muestra mensaje de ayuda para una función determinda. #.
Definition: System.lib:153
ogUnmountCache
function ogUnmountCache()
Desmonta la particion Cache y elimina la variable $OGCAC #.
Definition: Cache.lib:423
ogTypeToId
function ogTypeToId()
Devuelve el identificador correspondiente a un tipo de partición. #.
Definition: Disk.lib:1522
ogGetFsSize
function ogGetFsSize()
Muestra el tamanio del sistema de archivos indicado, permite definir la unidad de medida...
Definition: FileSystem.lib:335
ogGetPartitionActive
function ogGetPartitionActive()
Muestra que particion de un disco esta marcada como de activa. #.
Definition: Disk.lib:780
ogGetCacheSize
function ogGetCacheSize()
Devuelve el tamaño definido para la partición de caché. #.
Definition: Cache.lib:316
ogIdToType
function ogIdToType()
Devuelve el identificador correspondiente a un tipo de partición. #.
Definition: Disk.lib:1093
ogCreatePartitionTable
function ogCreatePartitionTable()
Genera una tabla de particiones en caso de que no sea valida, si es valida no hace nada...
Definition: Disk.lib:289
ogListPrimaryPartitions
function ogListPrimaryPartitions()
Metafunción que lista las particiones primarias no vacías de un disco. #.
Definition: Disk.lib:1236
ogSetPartitionSize
function ogSetPartitionSize()
Muestra el tamano en KB de una particion determinada. #.
Definition: Disk.lib:1435
ogGetPartitionType
function ogGetPartitionType()
Devuelve el mnemonico con el tipo de partición. #.
Definition: Disk.lib:1016
ogHidePartition
function ogHidePartition()
Oculta un apartición visible. #.
Definition: Disk.lib:1053
ogGetLastSector
function ogGetLastSector()
Devuelve el último sector usable del disco o de una partición. #.
Definition: Disk.lib:735
ogUpdatePartitionTable
function ogUpdatePartitionTable()
Fuerza al kernel releer la tabla de particiones de los discos duros #.
Definition: Disk.lib:1708
ogMountCache
function ogMountCache()
Monta la partición Cache y exporta la variable $OGCAC #.
Definition: Cache.lib:395
ogUnlockDisk
function ogUnlockDisk()
Elimina el fichero de bloqueo para un disco. #.
Definition: Disk.lib:1674
ogSetPartitionActive
function ogSetPartitionActive()
Establece cual es la partición activa de un disco. #.
Definition: Disk.lib:1332
sfdisk
function sfdisk()
Definition: ToolsGNU.c:139
partprobe
function partprobe()
Definition: ToolsGNU.c:135
ogFindCache
function ogFindCache()
Detecta la partición caché local. #.
Definition: Cache.lib:228
ogSetPartitionType
function ogSetPartitionType()
Cambia el identificador de la partición. #.
Definition: Disk.lib:1478
ogUnmountAll
function ogUnmountAll()
Desmonta todos los sistema de archivos de un disco, excepto el caché local. #.
Definition: FileSystem.lib:1096
ogListPartitions
function ogListPartitions()
Lista las particiones definidas en un disco. #.
Definition: Disk.lib:1204
fdisk
function fdisk()
Definition: ToolsGNU.c:101
ogCheckStringInGroup
function ogCheckStringInGroup()
Función para determinar si el elemento pertenece a un conjunto #.
Definition: String.lib:18
parted
function parted()
Definition: Disk.lib:13
ogLockDisk
function ogLockDisk()
Genera un fichero de bloqueo para un disco en uso exlusivo. #.
Definition: Disk.lib:1293
ogUnhidePartition
function ogUnhidePartition()
Hace visible una partición oculta. #.
Definition: Disk.lib:1632
ogCreateGptPartitions
function ogCreateGptPartitions()
Define el conjunto de particiones de un disco GPT #.
Definition: Disk.lib:191
ogGetPartitionsNumber
function ogGetPartitionsNumber()
Detecta el numero de particiones del disco duro indicado. #.
Definition: Disk.lib:915
ogGetEsp
function ogGetEsp()
Devuelve números de disco y partición para la partición EFI (ESP).
Definition: Disk.lib:697
ogEcho
function ogEcho()
Muestra mensajes en consola y lo registra en fichero de incidencias. #.
Definition: System.lib:34
ogGetDiskSize
function ogGetDiskSize()
Muestra el tamaño en KB de un disco. #.
Definition: Disk.lib:615
awk
function awk()
Definition: ToolsGNU.c:89
ogCreatePartitions
function ogCreatePartitions()
Define el conjunto de particiones de un disco. #.
Definition: Disk.lib:47
Generado por  TracDoxygen 0.7.5 & doxygen 1.8.11