Bagaimana saya bisa menggunakan bit mask pada / dev / zero sehingga saya bisa mendapatkan byte selain nol?

Bagaimana saya bisa memakai topeng bit /dev/zerosehingga saya dapat memiliki sumber tidak hanya untuk 0x00 tetapi juga untuk byte antara 0x01 dan 0xFF?

bashKode berikut ini diatur untuk bekerja dengan byte yang diwakili dalam biner . Namun Anda dapat dengan mudah mengubahnya untuk menangani ocatal , desimal atau hex dengan hanya mengubah radix r nilai 2 untuk 8, 10atau 16masing-masing dan pengaturan b=yang sesuai.

r=2; b=01111110
printf -vo '\\%o' "$(($r#$b))"; </dev/zero tr '\0' "$o"

EDIT - Ini menangani berbagai nilai byte: hex 00 - FF (ketika saya menulis 00-7F di bawah ini, saya hanya mempertimbangkan karakter byte tunggal UTF-8).

Jika, misalnya, Anda hanya ingin 4 byte (karakter dalam UTF-8 'ASCII'-only hex 00-7F range) , Anda dapat menyalurkannya ke head :... | head -c4

Output (4 karakter):

~~~~

Untuk melihat output dalam format 8-bit, masukkan ke dalam xxd(atau dump byte 1 dan 0 lainnya *):
mis. b=10000000dan perpipaan ke:... | head -c4 | xxd -b

0000000: 10000000 10000000 10000000 10000000                    ....

Anda tidak dapat dengan mudah melakukan itu.

Anda mungkin mempertimbangkan untuk menulis modul kernel Anda sendiri yang menyediakan perangkat seperti itu. Saya tidak merekomendasikan itu.

Anda dapat menulis sebuah program C kecil yang menulis aliran tak terbatas dari byte yang sama pada beberapa pipa (atau pada stdout) atau FIFO.

Anda dapat menggunakan tr (1) untuk membaca /dev/zerodan menerjemahkan setiap 0 byte ke sesuatu yang lain.

Anda bisa menggunakan mungkin ya (1) , setidaknya jika Anda mampu memiliki baris baru (atau pipa itu ke tr -d '\n'...)

Nah, jika Anda benar - benar ingin mencapai ini, Anda dapat menggunakan pengait LD_PRELOAD . Ide dasarnya adalah menulis ulang fungsi dari pustaka C dan menggunakannya sebagai ganti fungsi yang normal.

Berikut adalah contoh sederhana di mana kita menimpa fungsi read () ke XOR buffer output dengan 0x42.

#define _GNU_SOURCE
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <dlfcn.h> 
#include <unistd.h>

static int dev_zero_fd = -1;

int open64(const char *pathname, int flags)
{
    static int (*true_open64)(const char*, int) = NULL;
    if (true_open64 == NULL) {
        if ((true_open64 = dlsym(RTLD_NEXT, "open64")) == NULL) {
            perror("dlsym");
            return -1;
        }        
    }
    int ret = true_open64(pathname, flags);
    if (strcmp(pathname, "/dev/zero") == 0) {
        dev_zero_fd = ret;
    }
    return ret;
}


ssize_t read(int fd, void *buf, size_t count)
{
    static ssize_t (*true_read)(int, void*, size_t) = NULL;
    if (true_read == NULL) {
        if ((true_read = dlsym(RTLD_NEXT, "read")) == NULL) {
            perror("dlsym");
            return -1;
        }        
    }    

    if (fd == dev_zero_fd) {
        int i;
        ssize_t ret = true_read(fd, buf, count);    
        for (i = 0; i < ret; i++) {
            *((char*)buf + i) ^= 0x42;
        }
        return ret;
    }

    return true_read(fd, buf, count);    
}

Implementasi naif akan XOR 0x42 pada setiap file yang kita baca, yang akan memiliki konsekuensi yang tidak diinginkan. Untuk mengatasi masalah ini, saya juga mengaitkan fungsi open () , membuatnya mengambil deskriptor file yang terkait dengan / dev / zero. Kemudian, kita hanya menjalankan XOR pada fungsi read () kita jika fd == dev_zero_fd.

Pemakaian:

$ gcc hook.c -ldl -shared -o hook.so
$ LD_PRELOAD=$(pwd)/hook.so bash #this spawns a hooked shell
$ cat /dev/zero
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Dalam hal kecepatan, yang tercepat saya temukan adalah:

$ PERLIO=:unix perl -e '$s="\1" x 65536; for(;;){print $s}' | pv -a > /dev/null
[4.02GiB/s]

Untuk perbandingan:

$ tr '\0' '\1' < /dev/zero | pv -a > /dev/null
[ 765MiB/s]
$ busybox tr '\0' '\1' < /dev/zero | pv -a > /dev/null
[ 399MiB/s]

$ yes $'\1' | tr -d '\n' | pv -a > /dev/null
[26.7MiB/s]

$ dash -c 'while:; do echo -n "\ 1"; selesai '| pv -a> / dev / null
[225KiB / s]

$ bash -c 'while:; do echo -ne "\ 1"; selesai '| pv -a> / dev / null
[180KiB / s]

$ < /dev/zero pv -a > /dev/null
[5.56GiB/s]
$ cat /dev/zero | pv -a > /dev/null
[2.82GiB/s]

Agak ada gunanya mencoba dan bitmask / xor nol byte, bukan? Mengambil byte dan xormemasukkannya dengan nol adalah larangan.

Cukup buat satu loop yang memberi Anda byte yang Anda inginkan dan letakkan di belakang pipa atau pipa bernama. Ini akan berperilaku sama seperti perangkat karakter (tidak akan membuang siklus CPU saat idle):

mkfifo pipe
while : ; do echo -n "a"; done > pipe &

Dan jika Anda ingin mengoptimalkannya secara super, Anda dapat menggunakan kode C di bawah ini:

#include <stdio.h>
#include <string.h>

int main(int argc, char **argv) { 
  char c = argc == 1+1 ? argv[1][0] : 'y';

  char buff[BUFSIZ];
  memset(buff, c, BUFSIZ);

  for(;;){ 
    write(1, buff, sizeof(buff)); 
  }
}

kompilasi & jalankan

$ CFLAGS=-O3 make loop
./loop "$the_byte_you_want" > pipe

Uji kinerja:

./loop 1 | pv -a >/dev/null 

2.1GB / s pada mesin saya (bahkan sedikit lebih cepat dari cat /dev/zero | pv -a >/dev/null)

Baca nol, terjemahkan setiap nol ke pola Anda!

Kami membaca nol byte dari /dev/zero, dan gunakan truntuk menerapkan bit mask ke masing-masing byte dengan menerjemahkan setiap byte nol:

$ </dev/zero tr '\000' '\176' | head -c 10
~~~~~~~~~~$

Oktal 176 adalah kode ascii ~, jadi kami mendapatkan 10 ~. (Di $akhir output menunjukkan di shell saya bahwa tidak ada garis akhir - itu bisa terlihat berbeda untuk Anda)

Jadi, mari kita buat 0xFFbyte: Hex 0xFFadalah oktal 0377. Nol terdepan ditinggalkan untuk trbaris perintah; Pada akhirnya, hexdumpdigunakan untuk membuat output dapat dibaca.

$ </dev/zero tr '\000' '\377' | head -c 10 | hexdump
0000000 ffff ffff ffff ffff ffff               
000000a

Anda perlu menggunakan kode oktal karakter di sini, bukan heksadesimal. Jadi kisaran dari \000oktal \377(sama seperti 0xFF).
Gunakan ascii -xdan ascii -ountuk mendapatkan tabel karakter dengan angka indeks heksadesimal atau oktal.
(Untuk tabel dengan desimal dan heksadesimal, adil ascii).

Cukup cepat

Ini berjalan cukup cepat, dibandingkan dengan hanya menggunakan nol: cat /dev/zerohanya empat kali lebih cepat, sementara itu dapat memanfaatkan buffering IO dengan sempurna, yang trtidak bisa.

$ </dev/zero tr '\000' '\176' | pv -a >/dev/null
[ 913MB/s]

$ </dev/zero cat | pv -a >/dev/null        
[4.37GB/s]

Tergantung apa yang ingin Anda lakukan dengan data dan seberapa fleksibel Anda ingin menggunakannya.

Kasus terburuk jika Anda membutuhkan kecepatan, Anda dapat melakukan hal yang sama dengan / dev / zero, dan hanya mengkompilasi / dev / one, / dev / two, .. / dev / fourtytwo .. dan seterusnya perangkat.

Dalam kebanyakan kasus, lebih baik membuat data secara langsung di tempat yang diperlukan, jadi di dalam program / skrip sebagai konstanta. Dengan lebih banyak informasi, orang dapat lebih membantu Anda.

Infinte printf loop

Ganti \u00dengan byte yang Anda inginkan.

while true ; do printf "\u00" ; done | yourapp

Kode C ++:

#include<cstdio>

int main(){
 char out=Byte;
 while(true)
 fwrite(&out,sizeof(out),1,stdout);
}

Kompilasi: ganti Bytedengan nilai yang Anda inginkan.

g++ -O3 -o bin file.cpp -D Byte=0x01

Menggunakan

./bin | yourapp