如何在/ dev / zero上放置位掩码，以便可以获取非零的字节？

如何设置位掩码，/dev/zero以便不仅可以获取0x00的源，还可以获取0x01和0xFF之间的任何字节的源？

以下bash代码设置为以二进制表示的字节起作用。但是你可以很容易地改变它处理ocatal，十进制或十六进制通过简单地改变基数 r 的价值2 来8，10或16分别设置b=相应。

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

编辑 -它确实处理所有范围的字节值：十六进制 00 - FF（当我在下面编写00-7F时，我只考虑了单字节UTF-8字符）。

例如，如果您只需要4个字节（仅UTF-8'ASCII'十六进制00-7F范围内的字符），则可以将其传送到head中：... | head -c4

输出（4个字符）：

~~~~

看在8位格式的输出，管道将它导入xxd（或任何其他的1和0的字节转储*）：
例如。b=10000000并输送至：... | head -c4 | xxd -b

0000000: 10000000 10000000 10000000 10000000                    ....

您不能轻易做到这一点。

您可能会考虑编写自己的提供此类设备的内核模块。我不建议那样。

您可以编写一个微型C程序，在某个管道（或stdout）或FIFO 上写入相同字节的无限流。

你可以用 tr（1）读取/dev/zero每个0字节并将其转换为其他内容。

您可以使用yes（1），至少在您负担得起换行符的情况下（或将其换成tr -d '\n'...）

好吧，如果您确实想实现此目标，则可以使用 LD_PRELOAD挂钩。基本思想是从C库重写一个函数，然后使用它代替常规函数。

这是一个简单的示例，其中我们重写read（）函数以将输出缓冲区与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);    
}

一个幼稚的实现将对我们读取的每个文件进行XOR 0x42，这将带来不良后果。为了解决这个问题，我还钩住了open（）函数，使其获取与/ dev / zero关联的文件描述符。然后，如果仅对read（）函数执行XOR运算fd == dev_zero_fd。

用法：

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

在速度方面，我发现最快的是：

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

为了比较：

$ 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]

$破折号-c'while：; 做echo -n“ \ 1”; 完成” | pv -a> / dev / null
[225KiB / s]

$ bash -c'while ：; 做echo -ne“ \ 1”; 完成” | 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]

尝试将位掩码/异或为零字节是没有意义的，不是吗？取一个字节并将xor其清零是没有操作的。

只需创建一个循环，为您提供所需的字节，然后将其放在管道或命名管道的后面即可。它的行为与字符设备几乎相同（空闲时不会浪费CPU周期）：

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

如果您想对其进行超级优化，则可以使用下面的C代码：

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

编译并运行

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

性能测试：

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

我的机器上为2.1GB / s（甚至比还要快cat /dev/zero | pv -a >/dev/null）

读取零，将每个零转换为您的模式！

我们从中读取零字节/dev/zero，并tr通过转换每个零字节来对每个字节应用位掩码：

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

八进制176是的ASCII码~，因此我们得到10 ~。（$输出末尾的表示我的外壳中没有行尾-对您来说它可能看起来有所不同）

因此，让我们创建0xFF字节：十六进制0xFF为八进制0377。tr命令行的前导零被忽略了；最后，hexdump用于使输出可读。

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

您需要在此处使用字符的八进制代码，而不是十六进制。因此，范围是从\000到八进制\377（与相同0xFF）。
使用ascii -x和ascii -o获取具有十六进制或八进制索引号的字符表。
（对于具有十进制和十六进制的表，仅为ascii）。

蛮快

与仅使用零相比，它运行得相当快：cat /dev/zero仅是四倍，而它却可以完美利用IO缓冲，而这tr是不可能的。

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

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

取决于您要对数据进行何种操作以及使用数据的灵活性。

最糟糕的情况是，如果需要速度，则可以执行与/ dev / zero相同的操作，只需编译/dev/one、/dev/two、../dev/fourtytwo ..等设备。

在大多数情况下，最好直接在需要的地方创建数据，因此在程序/脚本中将其作为常量。有了更多信息，人们可以更好地帮助您。

无限printf循环

\u00用所需的字节替换。

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

C ++代码：

#include<cstdio>

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

编译：替换Byte为所需的值。

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

使用

./bin | yourapp