Как заставить grep искать всё, кроме образца?

           Canonical hex+ASCII display. Display the input offset in hexadecimal, followed by sixteen space-separated, two-column, hexadecimal bytes,  
           followed by the same sixteen bytes in %_p format enclosed in '|' characters. Invoking the program as hd implies this option.

sudo hexdump -C /dev/sde
00000000  01 00 00 00 02 00 00 00  03 00 00 00 00 00 00 00  |................|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
01ea0000

$ yes "123456789012345" | head -200 | hexdump -C
00000000  31 32 33 34 35 36 37 38  39 30 31 32 33 34 35 0a  |123456789012345.|
*
00000c80
$ 

xxd -g16 /dev/sde | grep -v "000000000000000"

colordiff <(unidump testwidth.txt) <(unidump testwidth2.txt)

$ sudo hexdump -C /dev/sde
00000000  01 00 00 00 02 00 00 00  03 00 00 00 00 00 00 00  |................|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000060  01 01 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000070  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
01ea0000

$ sudo xxd -g16 /dev/sde | grep -v "000000000000000"
00000000: 01000000020000000300000000000000  ................

xxd -g 16 binary.dat | grep -v $(for i in {1..16}; do echo -n "0"; done)

$ sudo xxd -g16 /dev/sde | grep -v "0000000000000000"
00000000: 01000000020000000300000000000000  ................

$ sudo xxd -g 16 /dev/sde | grep -v $(for i in {1..16}; do echo -n "0"; done)
00000000: 01000000020000000300000000000000  ................

sudo xxd -g 16 /dev/sde | grep -v $(for i in {1..16}; do echo -n "00"; done)

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#define BUFLEN 16
char hexxa[] = "0123456789abcdef0123456789ABCDEF", *hexx = hexxa;
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("Missing agrument.\n");
        return 1;
    }
    char buf[BUFLEN];
    char str_buf_hex[BUFLEN * 2 + 1] = {0};
    char str_buf[BUFLEN + 1] = {0};
    int f = open(argv[1], O_RDONLY);
    unsigned int offset = 0;
    if (f > 0)
    {
        while (1)
        {
            int b = read(f, buf, BUFLEN);
            if (b > 0)
            {
                int flag = 0;
                int i = 0, j = 0;
                for (; i < b; i++, j += 2)
                {
                    str_buf_hex[j] = hexx[(buf[i] >> 4) & 0xf];
                    str_buf_hex[j + 1] = hexx[buf[i] & 0xf];
                    (buf[i] < 32) ? str_buf[i] = '.' : (str_buf[i] = buf[i]);
                    if (buf[i] != 0)
                    {
                        flag = 1;
                    }
                }
                str_buf_hex[j] = 0;
                str_buf[i] = 0;
                if (flag)
                {
                    printf("%08lx: %s %s\n", offset, str_buf_hex, str_buf);
                }
                offset += b;
            }
            else
            {
                break;
            }
        }
        close(f);
    }
    else
    {
        printf("Unable to open %s\n", argv[1]);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

#define BUFLEN 16
#define UNPRINTCHAR 32
#define BUFCOUNT 10000
#define OFFSETLEN 16
#define LINELEN (OFFSETLEN + 1 + BUFLEN * 2 + 1 + BUFLEN + 1)

char *hexx = "0123456789abcdef";

void ulltohex(unsigned long long n, char *s)
{
    for (int i = 16; i >= 0; i--)
    {
        s[i] = hexx[n & 0x0f];
        n = n >> 4;
    }
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("Missing agrument.\n");
        return 1;
    }
    FILE *f = fopen(argv[1], "r");
    if (f > 0)
    {
        char *readbuf = malloc(BUFLEN * BUFCOUNT);
        if (readbuf != NULL)
        {
            unsigned long long offset = 0;
            static char line[LINELEN + 1];
            while (1)
            {
                size_t b_realread = fread(readbuf, 1, BUFLEN * BUFCOUNT, f);
                if (b_realread > 0)
                {
                    for (int c = 0; c < BUFCOUNT; c++)
                    {
                        size_t p_local = c * BUFLEN;
                        char *localbuf = &readbuf[p_local];
                        int pos_hex = OFFSETLEN + 2;
                        int pos_sym = OFFSETLEN + 2 + BUFLEN * 2 + 1;
                        int sum_check = 0;
                        for (int i = 0; i < BUFLEN; i++)
                        {
                            if (b_realread > (i + p_local))
                            {
                                line[pos_hex++] = hexx[(localbuf[i] >> 4) & 0xf];
                                line[pos_hex++] = hexx[localbuf[i] & 0xf];
                                line[pos_sym++] = (localbuf[i] < UNPRINTCHAR) ? '.' : localbuf[i];
                                sum_check += localbuf[i];
                            }
                            else
                            {
                                line[pos_hex++] = line[pos_hex++] = line[pos_sym++] = ' ';
                            }
                        }
                        if (sum_check != 0)
                        {
                            ulltohex(offset, line);
                            line[OFFSETLEN + 1] = line[OFFSETLEN + 1 + BUFLEN * 2 + 1] = ' ';
                            line[LINELEN] = '\n';
                            fputs(line, stdout);
                        }
                        offset += BUFLEN;
                    }
                }
                else
                {
                    break;
                }
            }
            free(readbuf);
        }
        else
        {
            printf("Unable to allocate memory\n");
        }
        fclose(f);
    }
    else
    {
        printf("Unable to open file %s\n", argv[1]);
    }
    return 0;
}

xxd -g 16 ~/binary.dat | grep -v "00000000000000000000000000000000"

sudo parted /dev/sdX unit s p free

 ls /dev/disk/by-
by-id/        by-label/     by-partlabel/ by-partuuid/  by-path/      by-uuid/