How do I get an equivalent of /dev/one in Linux

Question

You can use

dd if=/dev/zero of=file count=1024 bs=1024 

to zero fill a file.

Instead of that I want to one fill a file. How do I do that?

There is no /dev/one file, so how can I simulate that effect via on bash shell?

Answer 1

Try this:

dd if=<(yes $'\01' | tr -d "\n") of=file count=1024 bs=1024

Substitute $'\377' or $'\xFF' if you want all the bits to be ones.

Answer 2

tr '\0' '\377' < /dev/zero | dd bs=64K of=/dev/sdx

This should be much faster. Choose your blocksizes (or add counts) like you need at. Writing ones to a SSD-Disk till full with a blocksize of 99M gave me 350M/s write performance.

Answer 3

Well, you could do this:

dd if=/dev/zero count=1024 bs=1024 |
  tr '\000' '\001' > file

Answer 4

pv /dev/zero |tr \\000 \\377 >targetfile

...where \377 is the octal representation of 255 (a byte with all bits set to one). Why tr only works with octal numbers, I don't know -- but be careful not to subconsciously translate this to 3FF.

---

The syntax for using tr is error prone. I recommend verifying that it is making the desired translation...

cat /dev/zero |tr \\000 \\377 |hexdump -C

Note: pv is a nice utility that replaces cat and adds a progress/rate display.

Answer 5

I created a device driver in my github. Installing it creates a file /dev/one that is writing only bits set to 1.

The c file called one.c (the only interesting part is in device_file_read):

// File Driver to create a devince /dev/one like the /dev/zero

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>

MODULE_LICENSE("GPL");

static int device_file_major_number = 0;
static const char device_name[] = "one";

static ssize_t device_file_read(
        struct file *file_ptr,
        char __user *user_buffer,
        size_t count,
        loff_t *position) {
    printk( KERN_NOTICE "One: Device file is read at offset = %i, read bytes count = %u\n" , (int)*position , (unsigned int)count );

    // Allocate Kernel buffer
    char* ptr = (char*) vmalloc(count);

    // Fill it with one, byte per byte
    // -- Note that byte is the smallest accesible data unit
    memset(ptr, 0xFF, count);

    char res = copy_to_user(user_buffer, ptr, count);
    if (res != 0){ return -EFAULT; }

    // Return number of byte read
    return count;
}

static struct file_operations simple_driver_fops = {
    .owner   = THIS_MODULE,
    .read    = device_file_read,
};

int register_device(void) {
    int res = 0;
    printk( KERN_NOTICE "One: register_device() is called.\n" );
    res = register_chrdev( 0, device_name, &simple_driver_fops );
    if( res < 0 ) {
        printk( KERN_WARNING "One:  can\'t register character device with error code = %i\n", res );
        return res;
    }
    device_file_major_number = res;
    printk( KERN_NOTICE "One: registered character device with major number = %i and minor numbers 0...255\n", device_file_major_number );
    return 0;
}

void unregister_device(void) {
    printk( KERN_NOTICE "One: unregister_device() is called\n" );
    if(device_file_major_number != 0) {
        unregister_chrdev(device_file_major_number, device_name);
    }
}

static int my_init(void) {
    register_device();
    return 0;
}

static void my_exit(void) {
    unregister_device();
    return;
}

// Declare register and unregister command
module_init(my_init);
module_exit(my_exit);

The Makefile

TARGET_MODULE:=one

BUILDSYSTEM_DIR:=/lib/modules/$(shell uname -r)/build
PWD:=$(shell pwd)
obj-m := $(TARGET_MODULE).o
# See: https://stackoverflow.com/questions/15910064/how-to-compile-a-linux-kernel-module-using-std-gnu99
ccflags-y := -std=gnu99 -Wno-declaration-after-statement

build:
    # run kernel build system to make module
    $(MAKE) -C $(BUILDSYSTEM_DIR) M=$(PWD) modules

clean:
    # run kernel build system to cleanup in current directory
    $(MAKE) -C $(BUILDSYSTEM_DIR) M=$(PWD) clean
    rm -f MOK.priv MOK*.der

key:
    echo "Creating key"
    openssl req -new -x509 -newkey rsa:2048 -days 36500 -keyout MOK.priv -outform DER -out MOK.der -nodes -subj "/CN=TinmarinoUnsafe/"
    #
    echo "\e[31;1mPlease enter a password you will be asked for on reboot:\e[0m"
    mokutil --import MOK.der
    echo "\e[31;1mNow you must: 1/ reboot, 2/ Select Unroll MOK, 3/ Enter password you previously gave\e[0m"

sign:
    cp one.ko one.ko.bck
    /usr/src/linux-headers-$(shell uname -r)/scripts/sign-file sha256 MOK.priv MOK.der one.ko

load:
    insmod ./$(TARGET_MODULE).ko

unload:
    rmmod ./$(TARGET_MODULE).ko

create:
    mknod /dev/one c $(shell cat /proc/devices | grep one$ | cut -d ' ' -f1) 0

delete:
    rm /dev/one

test:
    [ "$(shell xxd -p -l 10 /dev/one)" = "ffffffffffffffffffff" ] \
        && echo "\e[32mSUCCESS\e[0m" \
        || echo "\e[31mFAILED\e[0m"

The instalation is long (3min) due to the driver signature enforcement. Froget this part if you disabled it in your UEFI.

1. git clone https://github.com/tinmarino/dev_one.git DevOne && cd DevOne # Download
2. make build # Compile
3. make key # Generate key for signing
4. sudo make sign # Sign driver module to permit MOK enforcement (security)
5. sudo reboot now # Reboot and enable Mok
   1. A blue screen (MOK manager) will appear
   2. Choose "Enroll MOK"
   3. Choose "Continue"
   4. Choose "Yes" (when asked "Enroll the key")
   5. Enter the password you gave at make sign
   6. Choose "Reboot" (again)
6. sudo make load # Load
7. sudo make device # Create /dev/one
8. make test # Test if all is ok

Answer 6

You can simulate a /dev/one without a special device, with a FIFO + printf (in a loop; slow) or yes (fast):

mkfifo ddfifo
dd if=ddfifo of=<file> iflag=fullblock count=1024 bs=1024 status=progress & while printf '\1'; do printf '\1'; done > ddfifo

Or:

mkfifo ddfifo
dd if=ddfifo of=<file> iflag=fullblock count=1024 bs=1024 status=progress & yes "" | tr '\n' '\1' > ddfifo

If you'd like bytes with all bits set to one, swap '\1' for '\377'.