Làm cách nào tôi có thể đặt mặt nạ bit trên / dev / zero để tôi có thể nhận được các byte khác 0?

Làm cách nào tôi có thể đặt mặt nạ bit /dev/zerođể tôi có thể có nguồn không chỉ cho 0x00 mà còn cho bất kỳ byte nào trong khoảng từ 0x01 đến 0xFF?

Đoạn bashmã sau được thiết lập để hoạt động với byte được biểu diễn dưới dạng nhị phân . Tuy nhiên bạn có thể dễ dàng thay đổi nó để xử lý ocatal , số thập phân hoặc hex bằng cách đơn giản thay đổi radix r giá trị của 2 để 8, 10hoặc 16tương ứng và thiết lập b=cho phù hợp.

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

EDIT - Nó xử lý toàn bộ phạm vi của các giá trị byte: hex 00 - FF (khi tôi viết 00-7F bên dưới, tôi chỉ xem xét các ký tự UTF-8 byte đơn).

Ví dụ: nếu bạn chỉ muốn 4 byte (các ký tự trong phạm vi hex 00-7F chỉ dành cho UTF-8 'ASCII) , bạn có thể đặt nó vào đầu :... | head -c4

Đầu ra (4 ký tự):

~~~~

Để xem đầu ra ở định dạng 8 bit, hãy đưa nó vào xxd(hoặc bất kỳ kết xuất byte 1 và 0 nào khác *):
vd. b=10000000và đường ống đến:... | head -c4 | xxd -b

0000000: 10000000 10000000 10000000 10000000                    ....

Bạn không thể dễ dàng làm điều đó.

Bạn có thể xem xét việc viết mô-đun hạt nhân của riêng bạn cung cấp một thiết bị như vậy. Tôi không khuyên bạn nên điều đó.

Bạn có thể viết một chương trình C nhỏ xíu viết một luồng vô hạn có cùng byte trên một số ống (hoặc trên stdout) hoặc FIFO.

Bạn có thể sử dụng tr (1) để đọc /dev/zerovà dịch mỗi 0 byte sang đôi khi khác.

Bạn có thể sử dụng có lẽ có (1) , ít nhất là nếu bạn có đủ khả năng để có những dòng mới (hoặc nếu không thì đưa nó vào tr -d '\n'...)

Chà, nếu bạn thực sự muốn đạt được điều này, bạn có thể sử dụng móc LD_PRELOAD . Ý tưởng cơ bản là viết lại một hàm từ thư viện C và sử dụng nó thay vì hàm bình thường.

Dưới đây là một ví dụ đơn giản trong đó chúng ta ghi đè hàm read () thành XOR bộ đệm đầu ra với 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);    
}

Một triển khai ngây thơ sẽ XOR 0x42 trên mỗi tệp chúng ta đọc, điều này sẽ có hậu quả không mong muốn. Để giải quyết vấn đề này, tôi cũng đã nối hàm open () , làm cho nó tìm nạp mô tả tệp được liên kết với / dev / zero. Sau đó, chúng tôi chỉ thực hiện XOR trong hàm read () nếu fd == dev_zero_fd.

Sử dụng:

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

Về tốc độ, nhanh nhất tôi tìm thấy là:

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

Để so sánh:

$ 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 :; làm tiếng vang -n "\ 1"; xong '| pv -a> / dev / null
[225Ki / giây]

$ bash -c 'while :; làm tiếng vang -ne "\ 1"; xong '| pv -a> / dev / null
[180Ki / giây]

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

Thật là vô nghĩa khi thử và bitmask / xor zero byte, phải không? Lấy một byte và lấy xornó bằng 0 là không có.

Chỉ cần tạo một vòng lặp cung cấp cho bạn các byte bạn muốn và đặt nó phía sau một đường ống hoặc đường ống có tên. Nó sẽ hoạt động khá giống với một thiết bị nhân vật (sẽ không lãng phí chu kỳ CPU khi không hoạt động):

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

Và nếu bạn muốn siêu tối ưu hóa nó, bạn có thể sử dụng mã C bên dưới:

#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)); 
  }
}

biên dịch và chạy

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

Kiểm tra hiệu suất:

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

2.1GB / s trên máy của tôi (thậm chí nhanh hơn một chút cat /dev/zero | pv -a >/dev/null)

Đọc số không, dịch từng số 0 vào mẫu của bạn!

Chúng tôi đọc các byte không trong số đó /dev/zerovà sử dụng trđể áp dụng mặt nạ bit cho mỗi byte bằng cách dịch từng byte 0:

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

Octal 176 là mã ascii của ~, vì vậy chúng tôi nhận được 10 ~. (Ở $cuối đầu ra cho biết trong vỏ của tôi rằng không có đầu cuối dòng - nó có thể trông khác với bạn)

Vì vậy, hãy tạo 0xFFbyte: Hex 0xFFlà bát phân 0377. Số 0 đứng đầu được để lại cho trdòng lệnh; Cuối cùng, hexdumpđược sử dụng để làm cho đầu ra có thể đọc được.

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

Bạn cần sử dụng mã bát phân của các ký tự ở đây, thay vì thập lục phân. Vì vậy, đó là phạm vi từ \000đến bát phân \377(giống như 0xFF).
Sử dụng ascii -xvà ascii -ođể có được một bảng các ký tự có số chỉ số thập lục phân hoặc bát phân.
(Đối với một bảng có thập phân và thập lục phân, chỉ ascii).

Khá nhanh

Nó chạy khá nhanh, so với việc chỉ sử dụng các số không: cat /dev/zerochỉ nhanh gấp bốn lần, trong khi nó có thể sử dụng bộ đệm IO hoàn hảo, điều này trkhông thể.

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

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

Phụ thuộc vào những gì bạn muốn làm với dữ liệu và mức độ linh hoạt bạn muốn sử dụng nó.

Trường hợp xấu nhất nếu bạn cần tốc độ, bạn có thể làm tương tự như / dev / zero và chỉ cần biên dịch / dev / one, / dev / hai, .. / dev / Fourtytwo .. và trên các thiết bị.

Trong hầu hết các trường hợp, tốt hơn là tạo dữ liệu trực tiếp ở nơi cần thiết, vì vậy bên trong một chương trình / tập lệnh là một hằng số. Với nhiều thông tin mọi người có thể giúp bạn tốt hơn.

Vòng lặp in Infinte

Reeplace \u00với byte bạn muốn.

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

Mã C ++:

#include<cstdio>

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

Biên dịch: reeplace Bytevới giá trị bạn muốn.

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

Sử dụng

./bin | yourapp