Estou trabalhando em um Linux embarcado. Quero escrever um script bash que corrija partições automaticamente.

Declarei um array associativo onde a chave é o ponto de montagem e o valor é o dispositivo a ser montado.

Agora, meu problema é que os dispositivos podem ter sistemas de arquivos diferentes e a versão correta fsckdeve ser selecionada.

Cada sistema de arquivos tem sua própria fsckvariante, como fsck.vfate fsck.ext4.

Preciso trazer isso de alguma forma para que a variante correta seja chamada. Infelizmente, a variante principal fscknão fornece correção ou detecção automática de sistemas de arquivos em minha configuração.

Então a verdadeira questão é como ter uma tabela de pesquisa aqui?

declare -A arrPartitionsToCheck=(
[/run/media/my-backup]="/dev/sda1" # vfat
[/run/media/my-data]="/dev/sdb1"   # ext4
)

for part in "${!arrPartitionsToCheck[@]}"; do

    # Unmount
    # umount /dev/sda1
    umount "${arrPartitionsToCheck[$part]}"

    # Select the right variant of FSCK and repair automatically
    fsck.vfat -a "${arrPartitionsToCheck[$part]}"

    # Mont Again! For example
    # mount /dev/sda1 /run/media/my-backups
    mount "${arrPartitionsToCheck[$part]}" "$part"    

done

Vi que é possível conectar dois computadores por cabo USB e fazer uma ponte ethernet virtual ou algo parecido.

Minha pergunta é: podemos fazer algo semelhante, mas configurar a conexão como uma interface SERIAL?

Para ser exato:

É possível conectar dois computadores com um cabo USB (não sei qual é o nome correto, quero dizer um cabo que tem conector USB-A nas duas extremidades) sem nenhum adaptador serial envolvido e depois configurar a porta USB como serial .

Eu tenho um conjunto bastante complexo de arquivos a serem encontrados e reagidos (por exemplo, caminhos copiados para um arquivo de texto):

Por exemplo:

 find / \( -iname "*ssh*" -or -iname "*scp*" \) \( -not -path -"/run" -not -path "/rw/*" -and -not -path "/home/*" -and -not -path "*/qml/*" \) >> ~/files.txt

Aqui, desejo encontrar todos os arquivos ou pastas relacionados a "ssh" e "scp", mas não nos diretórios /run ou /rw.

Estarei adicionando mais condições a isso, mas os comandos ficam muito longos. Como posso fazer isso com regex?

Trabalho com um software de código aberto que construí localmente. Após a compilação, o manual diz para executá-lo assim enquanto estiver dentro do diretório de compilação

$ LD_LIBRARY_PATH=../applicationExeFile

Em seguida, o aplicativo funciona bem.

Agora tentei fazer um shell simples para chamar rapidamente sem digitar muito (run.sh) com o seguinte conteúdo:

#!/bin/bash

export -n LD_LIBRARY_PATH=.
./applicationExeFile

Mas parece que LD_LIBRARY_PATH não fica registrado no shell pois recebo erro referente ao executável do aplicativo não consigo encontrar uma biblioteca que esteja na mesma pasta

./applicationExeFile: error while loading shared libraries: libchart.so: cannot open shared object file: No such file or directory

O que estou fazendo de errado e como conseguir isso?

Eu quero gerar alguns arquivos grandes para algum experimento.

Este é o meu roteiro. Ele cria um arquivo, em seguida, o lê para uma variável e tenta escrevê-lo quantas vezes forem definidas no loop em arquivos:

#! /usr/bin/env bash

set -e
set -u

< /dev/urandom tr -dc "\t\n [:alnum:]" | head -c32768 > temp.txt
data=$(cat ./temp.txt)

for testdir in "$@"; do
    echo "create directory '$testdir'"
    mkdir -p $testdir
    for i in {1..3}; do
        counter=$(printf %02d $i)
        testfile=$testdir/test_${testdir##*/}_$counter.txt
        echo "create file '$testfile'"
        echo "$data" > $testfile
    done
done

Se eu tentar usar este script para criar 3000 arquivos (cada pasta terá 3 arquivos) demora cerca de 19s no meu sistema:

tempo generateUserData.sh TESTE{0..1000}

create directory 'TEST999'
create file 'TEST999/test_TEST999_01.txt'
create file 'TEST999/test_TEST999_02.txt'
create file 'TEST999/test_TEST999_03.txt'
create directory 'TEST1000'
create file 'TEST1000/test_TEST1000_01.txt'
create file 'TEST1000/test_TEST1000_02.txt'
create file 'TEST1000/test_TEST1000_03.txt'

real    0m19.333s
user    0m14.791s
sys     0m4.784s

O reconhecimento echopode ser a parte lenta aqui. Alguma ideia de como posso fazer o dele o mais rápido possível?

Eu quero fazer algumas árvores de diretórios e preencher cada extremidade da árvore com um arquivo de texto com conteúdo aleatório.

Aqui está o que eu tentei até agora:

#!/bin/bash

set -e

echo "Generating test folders"

mkdir -p ./parent_{0..9}/child_{0..9}
head -c 100 /dev/urandom | xargs echo >> ./parent_{0..9}/child_{0..9}/test.txt

echo "done"

Ao executar, recebo este erro:

./gen-test.sh: line 8: ./parent_{0..9}/child_{0..9}/test.txt: ambiguous redirect

O que estou fazendo de errado e qual poderia ser uma abordagem mais inteligente para essa tarefa?

Eu tenho um script Bash com uma função para registrar mensagens com hora e status, e quero manter meu script apenas com 80 colunas:

#!/bin/bash

log_message() {
  echo "[$(date)]-[$1] : $2" >> log.txt
}

varName="John Doe"

# line break to not exceed 80 columns
log_message "WARNING" "I am "${varName}" and i want to limit this line \
to 80 columns"

O resultado no arquivo de log não é o esperado:

[Fri Jun 24 13:50:12 CEST 2022]-[WARNING] : I am John

Qual é a maneira correta de fazer isso no Bash?

Preciso descobrir qual é o número da linha da primeira ocorrência de uma determinada string de pesquisa que deve estar no início de uma linha em um arquivo de texto e armazená-la em uma variável no meu script bash. Por exemplo, quero encontrar a primeira ocorrência de "c":

abc
bde
cddefefef // this is the line that I need its line number
Casdasd // C here is capital, I dont need it
azczxczxc
b223r23r2fe
Cssdfsdfsdf
dccccdcdcCCDcdccCCC
eCCCCCC

Eu inventei isso, mas como você vê, há grandes problemas

   trimLineNum=$(cat "${varFileLog}" | grep -m1 -n "c")
   echo "c is at line #"${trimLineNum}

A saída será:

c is at line #1:abc

Problemas:

1. Então, obviamente, corresponde à primeira linha, porque há um "c" na linha.
2. A saída também incluirá o conteúdo da linha! Eu quero que seja apenas o número da linha

o que devo mudar para corrigir esses problemas?

Eu criei um script bash para executar alguns outros programas com variáveis ​​de ambiente personalizadas. Aqui está meu primeiro script chamado run-hello.shem/home/user

#!/bin/bash    
export PATH=$PATH":/home/user/cool/path"    
hello.sh     
exit 0

E em /home/user/cool/patheu tenho o hello.shscript:

#\!/bin/bash
echo Hello from $(pwd)

A execução do primeiro script (run-hello.sh) produz:

Hello from /home/user

Minhas perguntas:

1. o exportchamado no primeiro script só é válido pela duração em que o script estava ativo? Se depois de executar o script eu echo $PATHnão ver o caminho adicionado pelo script... Este é o comportamento pretendido? Como posso fazê-lo resistir pelo menos durante a duração do terminal?

2. Por que o resultado é impresso /home/userem vez de /home/user/cool/path?

Eu quero criar um script no Linux para criar alguns diretórios se eles não existirem. Os diretórios são declarados dentro do próprio script (não sendo passados ​​da linha de comando):

#!/bin/bash

varBaseDir="/home/user"

# Directories to create
varAppDir="${varBaseDir}/app"
varAppDataDir="${varBaseDir}/appData"

if [[ -d ${varAppDir} ]]
        then
                echo "app dir exist"
        else
                echo "app dir does not exist! creating '${dir}' ..."
                mkdir -p ${dir}
                if test "$?" -eq "0"
                        then
                                        echo "succeeded."
                        else
                                echo "failed to create directory"
                fi
fi

Como você pode ver eu crio um dos diretórios. Então eu precisaria repetir o mesmo código novamente, mas com um diretório diferente (na próxima vez eu quero que o varAppDataDir seja criado).

Eu tentei descobrir como declarar uma função:

my_function($dir) {
        echo $dir
}

my_funciotn("HELLO")

mas recebo erro:

./test.sh: line 27: syntax error near unexpected token `$dir'
./test.sh: line 27: `my_function($dir) {'

Então, como fazer isso direito?

Digamos que eu tenha 50 unidades flash USB.

Eu suponho que eles chegam a /dev/sdaser /dev/sdz. O que vem depois /dev/sdz?

Uma unidade flash normal é reconhecida como /dev/sdXpelo linux.

Como é chamado esse raw /dev/sdX, principalmente antes da montagem.

Quando for montado, será como /mountpath/sdX1se tivesse uma partição, certo?

Quais são as terminologias aqui? como nomeamos estes?

Quais são as outras possibilidades? Eu sei sdXque deve significar SCSI, mas o que mais pode ser esperado quando você conecta uma unidade flash ou disco rígido externo ou talvez unidade de disquete USB / unidade óptica?

Estou conectando através de ssh a um linux embutido para fazer algumas coisas. Na saída de comandos como journalctle systemctlvejo esses caracteres aleatórios que se parecem com diretivas de cores. Eles realmente arruinaram a aparência dos logs e eu simplesmente não quero vê-los. Existe alguma maneira que eu possa me livrar dele? ou de alguma forma fazê-lo funcionar?

Mar 29 08:27:02 MyHost kernel: EXT4-fs (sda6): mounting ext3 file system using the ext4 subsystem
Mar 29 08:27:02 MyHost udisksd[2051]: [[0;1;39m[[0;1;31m[[0;1;39mMounted /dev/sda6 at /run/media/root/TYPE-EXT3 on behalf of uid 0[[0m

$SHELL está definido como/bin/bash