how to use dd to fill drive with 1's

Simply do:

tr '\0' '\377' < /dev/zero > /dev/sdb

It will abort with an error when the drive is full.

Using dd does not make sense here. You use dd to make sure reads and writes are made of a specific size. There's no reason to do it here. tr will do reads/writes of 4 or 8 kiB which should be good enough.

For a faster /dev/urandom alternative, there is shred -v -n 1 (if pseudorandom is OK), or using cryptsetup with random key and zeroing that (for encrypted zeroes). Even without AES acceleration, it easily beats /dev/urandom speeds.

Not sure how fast tr is, otherwise you could just dd if= | tr | dd of=.

Using a file as a pattern source could be done like this:

(while [ 1 ]; do cat file; done) | dd of=...

Although the file should be reasonably large for that to be remotely efficient.

If the count= is important to you, add iflag=fullblock to the dd command. Partial reads are possible which would result in partial blocks to be counted as full blocks. This is especially when using larger blocksizes (like bs=1M), which you should if you want speed.

I am editing my answer here as I came across a boot disc that didn't even have AWK available (just dd and tr were my only familiar friends available):

dd if=/dev/zero bs=65536 | tr '\0' '\377' | dd of=/dev/sda bs=65536

I found it necessary for speed/performance reasons to choose a 64 kB block size for my disk drive.

The performance of the above command was equal to my first pass of dd if=/dev/zero of=/dev/sda bs=65536 (took about 37 minutes to fill a 75 GiB ATA disk drive, ~35 MiB/s)

badblocks -v -w -s -b physical block size -t 0xff /dev/the device

Example to write all ff to 4K native HDD at /dev/sdb plus read it back to verify ff was actually written to every block:

$ sudo badblocks -v -w -s -b 4096 -t 0xff /dev/sdb

To test the SSD speed, I wrote a little Perl program to write "zeros", "ones" or alphanumerics to a block device given on the command line. It doesn't invoke the dd golem, just does direct writes and syncs. May be of help here:

https://github.com/dtonhofer/wild_block_device_filler

Just run it as

wildly_fill_block_device.pl --dev=sdX1 --fillpat 1 --chunksize=1024P --sync

And it will write 0xFFs to /dev/sdX1 (unbuffered, using Perl's syswrite()) in chunks of (in this case) "1024 physical blocks" while synch-ing the data to disk after every write using fdatasync(). On my SSD, this runs at ~70 MiB/s.

It will ask you whether you are SURE before it proceeds to nuke the partition or disk.

You can do it pretty efficiently in Bash without external files, except the device to write to, or external commands, except dd.

1. Use printf to generate a byte with all one bits, and put it in a Bash variable.
2. Concatenate the Bash variable to itself multiple times.
3. Use Bash process substitution to fake an infinitely long input file that repeatedly echoes the Bash variable with no trailing newline.
4. Use that as the input file to dd.

If you have GNU dd, get a nice progress bar with:

sudo -i
bash
ones="$( printf '\xff' )"; for _ in {1..16}; do ones="$ones$ones"; done; dd status=progress bs=65536 if=<( while true; do echo -n "$ones"; done ) of=/dev/whatever

Remove the status=progress if it doesn't work for you. The 65536 is 2¹⁶, because the initial byte with all one bits was duplicated 16 times.

You can simulate a /dev/one without a special device, with a FIFO + yes:

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

tee may be used to double the throughput:

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

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

How to wipe with 1's:

while true; do echo 1 ; done | dd of=/dev/sdX status=progress

How to test the wipe:

dd if=/dev/sdX count=1 bs=512