Announcement

Collapse
No announcement yet.

Would like some assistance

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

    #46
    Originally posted by jlittle View Post

    I suspect, and hope, that's old advice. On my main desktop for the system and my home subvolumes I have about 45 snapshots each, roughly half from my backup scheme, which does incrementals to several different drives (each needing a different previous), and half from snapper. I've got 25 or so other subvolumes, mostly other installs and for volatile data I don't want in the backups, such as browser caches and large downloads. Sometimes I've got a lot more subvolumes, when I've got an install that I start snapper in; I often do that with an LTS release.

    I just make sure the fs doesn't fill up, and performance is good. It's still showing ~ 50 GiB unallocated out of 216 GiB, and 62 GiB free. I think keeping the volatile data out of the main subvolumes is working. Lots of snapshots doesn't in principle take up a lot of space, just metadata. For example, take a subvolume with data that changes or grows gradually, with a snapshot each month for a year; a snapshot each week over the same period mostly requires some more metadata, so won't take up much more space.

    With mainstream distros now making btrfs the default file system, and OpenSUSE installing snapper by default, I expect there's many users that have subvolumes with a lot more than 8 snapshots.
    I haven't found any other reputable source which advocates for more snapshots per volume than the BTRFS developers "low double and single digit" number of snapshots per subvolume. I read one person stating that BTRFS supports 2^64 subvolumes. It doesn't. It supports 2^64 bytes per subvolume size. Many seem to pull their number of supported snapshots, like 100, out of dark smelly places.

    The problem has always been that snapshots eventually fill up if left alone, and when their combined total size, plus the operating system size, goes over 90% the performance begins to suffer, and so do maintenance tools like balance, scrub, check and others.

    When I first started using BTRFS over five years ago I went snapshot wild, creating 50-100, along with pre and post package updates. I never got to the 90% threshold but I began to wonder, as I looked at the older snapshots, "what am I keeping them for?" Why would I ever revert to a snapshot that is a month old, much less a year old, or older? I thought of all the data I'd lose reverting to an old snapshot -- emails, calendar data, app installs, DE customizations, code I'd written, etc... Had I upgraded my distro version why would I want to revert to the previous or older version in an old snapshot?

    That's when I started copying data I wanted to keep long term, like my wife's genealogy and family tree data, my old coding (SAVVY, Turbo Pascal 3.02A, Pascal), my math and physics documents, etc., to multiple external disk drives as themselves, without using any intervening technology like BTRFS. That data never changes. It is like a photo of my family hanging on the wall. But, I have that data on my current system as well, for occasional reference and trips down memory lane. The TP302A files date from June of 1992, and my Lotus AmiPro spreadsheets (.SAM) that I used to invoice my clients date from before that.

    I've had clients that generated data and documentation that laws required they keep for 15 years. That data was printed out on paper and stored in indexed cardboard boxes which were stacked six high in warehouses. When some lawyer wanted a certain document a gofer was sent over to retrieve it and make a photocopy of it, returning the original to the box. If you ran a spreadsheet written with Lotus Notes having a paper copy was/is the only reliable way to save that data. Think where they'd be if they had stored their spreadsheet files on Zip drives. Fifteen years later the drives don't work and Lotus Notes died long ago. That spreadsheet data is lost for good. I keep my .SAM spreadsheets on the hope that someone will make a converter for them.

    For my use case BTRFS is perfect: quick and easy to use. I limit my snapshots to around 5 for my only subvolume, @. I always do a snapshot before I run an update and full-upgrade. If things don't go well I can roll back quickly. No harm, no foul. If after I check my WINE apps, virtual machines, my Jupyter Notebooks, and my steam games and everything runs well I will create a new snapshot. I always delete the oldest snapshot when I create a new one, maintaining the 5 snapshot count. I always plug in my 500Gb USB SSD drive when running make_snapshots.sh to keep a "take with me copy" of my Neon installation. I have a 1Tb NVMe SSD also labeled "BACKUP" and when my USB SSD, which is labeled "BACKUP" as well, is not plugged in the mount command in my script mounts the NVMe.

    PS - My use case is testing distros in VM's, creating Jupyter Notebooks to test Covid and other data for validity, emailing friends and relatives, shopping online, keeping up with news and weather, visiting KubuntuForums.net and other websites, and playing games locally, mainly Minecraft. Simple uses. One nice feature of BTRFS is that I can navigate through a snapshot and pull out files and folders as if they were on an EXT4, or C:/ drive, or what ever.
    Last edited by GreyGeek; Mar 10, 2022, 10:07 AM.
    "A nation that is afraid to let its people judge the truth and falsehood in an open market is a nation that is afraid of its people.”
    – John F. Kennedy, February 26, 1962.

    Comment


      #47
      Thank you for your considered reply.
      Originally posted by GreyGeek View Post
      The problem has always been that snapshots eventually fill up if left alone, and when their combined total size, plus the operating system size, goes over 90% the performance begins to suffer, and so do maintenance tools like balance, scrub, check and others.
      For snapper, the problem is now mitigated by the SPACE_LIMIT and FREE_LIMIT in the configuration.
      Regards, John Little

      Comment


        #48
        Okay, I'm at my wits end. I've been troubleshooting this for nearly a full day (24-hours). I just don't see where I've gone wrong.

        Here's my testing script.
        #!/bin/bash
        STARTCLOCK=$(date +%s)
        # snapshot.sh
        # Created: 2022-03-08
        #
        # Change Log:
        # Syntax to use:
        # YYYY-MM-DD
        # What was done
        #

        # To be run as root from /
        #
        # Before executing this script:
        # Plug in external HDD and ignore Disk & Devices pop-up.
        # External drive will be powered and identified by system but not yet mounted.
        #

        # Variables

        NOW=$(date +%Y%m%d%H%M)
        ROOTNOW=@$(date +%Y%m%d%H%M)
        HOMENOW=@home$(date +%Y%m%d%H%M)
        MKSNAP1="btrfs su snapshot -r /mnt/@ /mnt/snapshots/$ROOTNOW"
        MKSNAP2="btrfs su snapshot -r /mnt/@home /mnt/snapshots/$HOMENOW"

        # Start Snapshot Process

        echo "Mounting drives"

        # mount internal HDD to /mnt

        eval "mount /dev/disk/by-label/LAPTOP /mnt"
        echo "Internal HDD mounted to /mnt"
        echo ""

        # mount external HDD to /backup

        eval "mount /dev/disk/by-label/USBHDD /backup"
        echo "External USB HDD mounted to /backup"
        echo ""

        # Display Timestamp

        echo "Timestamp: $NOW"
        echo ""

        # Create todays Full snapshots of @ and @home

        echo "Making today's snapshot of @"
        eval $MKSNAP1
        eval 'sync;sync'
        echo "$ROOTNOW successfully created"
        echo ""

        echo "Making today's snapshot of @home"
        eval $MKSNAP2
        eval 'sync;sync'
        echo "$HOMENOW successfully created"
        echo ""

        # Find previous @ snapshot as parent"

        ROOTLIST=($(ls /mnt/snapshots/|grep '^@2'))
        PREVROOTLIST=${ROOTLIST[-2]}
        NOW=${ROOTLIST[-1]}
        echo "Attempting incremental backup of @home"
        if [[ -s "/mnt/snapshots/"$PREVROOTSNAP ]];
        then
        MKINC='btrfs send -p /mnt/snapshots/'$PREVROOTSNAP
        MKINC=$MKINC' /mnt/snapshots'$NOW
        MKINC=$MKINC' | btrfs receive /backup'
        echo $MKINC
        eval $MKINC
        eval 'sync;sync;sync'
        DELROOTSNAP='btrfs subvol delete -C /mnt/snapshots'${ROOTLIST[0]}
        eval $DELROOTSNAP
        eval 'sync;sync;sync'
        ROOTLIST=''
        ROOTLIST=($(ls /backup/| grep '^@2'))
        DELROOTSNAP='btrfs subvol delete -C /backup/'${ROOTLIST[0]}
        eval $DELROOTSNAP
        eval 'sync;sync;sync'
        echo "Snapshots of @ completed, oldest @ snapshots deleted."
        else
        echo 'Incremental @ backup failed using '$PREVROOTLIST' and '$NOW
        fi

        # Find previous @home snapshot as parent"

        HOMELIST=($(ls /mnt/snapshots/|grep '^@home2'))
        PREVHOMESNAP=${HOMELIST[-2]}
        NOW=${HOMELIST[-1]}
        echo "Attempting incremental backup of @home"
        if [[ -s "/mnt/snapshots/"$PREVHOMESNAP ]];
        then
        MKINC='btrfs send -p /mnt/snapshots/'$PREVHOMESNAP
        MKINC=$MKINC' /mnt/snapshots'$NOW
        MKINC=$MKINC' | btrfs receive /backup'
        echo $MKINC
        eval $MKINC
        eval 'sync;sync;sync'
        DELHOMESNAP='btrfs subvol delete -C /mnt/snapshots'${HOMELIST[0]}
        eval $DELHOMESNAP
        eval 'sync;sync;sync'
        HOMELIST=''
        HOMELIST=($(ls /backup/| grep '^@home2'))
        DELHOMESNAP='btrfs subvol delete -C /backup/'${HOMELIST[0]}
        eval $DELHOMESNAP
        eval 'sync;sync;sync'
        echo "Snapshots of @home completed, oldest @home snapshots deleted."
        else
        echo 'Incremental @home backup failed using '$PREVHOMESNAP' and '$NOW
        fi

        # Calculate and display how much time creating and sending snapshots took

        STOPCLOCK=$(date +%s)
        SECS=$((STOPCLOCK - STARTCLOCK))
        DURATION=$(date --date "0 $(($(date +%s) - STARTCLOCK)) sec" +%Hh:%Mm:%Ss)
        echo ""
        echo "Total process took: $DURATION"
        echo ""

        # Cleanup

        ## Commented during testing so I don't have to keep unplugging/plugging my USB HDD
        #eval 'sync;sync;sync'
        #eval 'umount /backup'
        #eval 'umount /mnt'
        #eval 'sync;sync;sync'
        #echo "Drives unmounted. Powering off external USB HDD"
        #eval 'udisksctl power-off -b /dev/disk/by-label/USBHDD'
        echo ""
        echo "Finished"
        I'm running the script with nothing yet in /mnt/snapshots or /back

        The @ and @home snapshots get created in /mnt/snapshots quickly, but the creation/sending of the @ and @home incremental snapshots to /backup fails.

        This is the output running the script:
        root@barley-cat:/# /snapshotTESTC.sh
        Mounting drives
        Internal HDD mounted to /mnt

        External USB HDD mounted to /backup

        Timestamp: 202203101833

        Making today's snapshot of @
        Create a readonly snapshot of '/mnt/@' in '/mnt/snapshots/@202203101833'
        @202203101833 successfully created

        Making today's snapshot of @home
        Create a readonly snapshot of '/mnt/@home' in '/mnt/snapshots/@home202203101833'
        @home202203101833 successfully created

        /snapshotTESTC.sh: line 76: ROOTLIST: bad array subscript
        Attempting incremental backup of @home
        btrfs send -p /mnt/snapshots/ /mnt/snapshots@202203101833 | btrfs receive /backup
        ERROR: failed to get flags for subvolume /mnt/snapshots: Invalid argument
        ERROR: empty stream is not considered valid
        ERROR: Could not statfs: No such file or directory
        WARNING: not deleting default subvolume id 5 '//backup'
        Snapshots of @ completed, oldest @ snapshots deleted.
        /snapshotTESTC.sh: line 103: HOMELIST: bad array subscript
        Attempting incremental backup of @home
        btrfs send -p /mnt/snapshots/ /mnt/snapshots@home202203101833 | btrfs receive /backup
        ERROR: failed to get flags for subvolume /mnt/snapshots: Invalid argument
        ERROR: empty stream is not considered valid
        ERROR: Could not statfs: No such file or directory
        WARNING: not deleting default subvolume id 5 '//backup'
        Snapshots of @home completed, oldest @home snapshots deleted.

        Total process took: 00h:00m:02s


        Finished
        root@barley-cat:/#
        What /mnt/snapshots has afterwards:
        Code:
        root@barley-cat:/# vdir /mnt/snapshots 
        total 0 
        drwxr-xr-x 1 root root 354 Mar 10 18:21 @202203101833 
        drwxr-xr-x 1 root root  36 Mar  1 20:42 @home202203101833
        /backup contains nothing.
        Windows no longer obstructs my view.
        Using Kubuntu Linux since March 23, 2007.
        "It is a capital mistake to theorize before one has data." - Sherlock Holmes

        Comment


          #49
          Both incremental backups are suffering from the same problem:
          btrfs send -p /mnt/snapshots/ /mnt/snapshots@202203101833 | btrfs receive /backup
          The child snapshot name is missing. It should be:
          btrfs send -p /mnt/snapshots/@yyyymmddhhmm /mnt/snapshots@202203101833 | btrfs receive /backup
          which is supposed to be supplied by $PREVROOTSNAP and $PREVHOMESNAP.
          They, in turn, should be populated by the ls command and curly brackets manipulation:
          ROOTLIST=($(ls /mnt/snapshots/|grep '^@2'))
          PREVROOTLIST=${ROOTLIST[-2]}
          I generally put spaces around my pipes, and try using just one ():
          ROOTLIST=$(ls /mnt/snapshots | grep '^@2')
          Here I messed around with listing some files in my PWD;

          $ ls | grep '^w'
          wacom_tablet_installation.odt
          webcam_video_audio_capture_cli.txt
          widgets.png
          winehq.key
          working
          wpa_tui.sh


          $ list=($(ls | grep '^w'))
          $ echo ${list[-2]}
          working
          $ echo ${list[-1]}
          wpa_tui.sh
          $ echo ${list[0]}
          wacom_tablet_installation.odt
          $ echo ${list[1]}
          webcam_video_audio_capture_cli.txt

          $ echo ${list[2]}
          widgets.png


          Strange indexing, isn't it?


          "A nation that is afraid to let its people judge the truth and falsehood in an open market is a nation that is afraid of its people.”
          – John F. Kennedy, February 26, 1962.

          Comment


            #50
            Originally posted by GreyGeek View Post
            Strange indexing, isn't it?
            What do you mean? Looks right to me, list[0] is the first variable of the array, list[1] is the second, list[-1] is the last and list[-2] is the second to last.

            Didn't read the whole thread or looked at the script, so no comments on the issue itself.
            Last edited by kubicle; Mar 10, 2022, 11:29 PM.

            Comment


              #51
              You're right ... my bad.
              "A nation that is afraid to let its people judge the truth and falsehood in an open market is a nation that is afraid of its people.”
              – John F. Kennedy, February 26, 1962.

              Comment


                #52
                Already found/fixed typos in my script, which were the cause of some of the errors.

                I've echoed the script up to the point of the command to make the incremental snapshot of @ and have it received on /backup. That command is executed and then I Ctrl+C out of the script. If the @ incremental section isn't working, so the @home incremental section would fail as well.

                root@barley-cat:/# /snapshotTESTE.sh
                Mounting drives
                mount: /mnt: /dev/sda1 already mounted on /.
                Internal HDD mounted to /mnt

                mount: /backup: /dev/sdb1 already mounted on /backup.
                External USB HDD mounted to /backup

                Timestamp: 202203111047

                Making today's snapshot of @
                Create a readonly snapshot of '/mnt/@' in '/mnt/snapshots/@202203111047'
                @202203111047 successfully created

                Making today's snapshot of @home
                Create a readonly snapshot of '/mnt/@home' in '/mnt/snapshots/@home202203111047'
                @home202203111047 successfully created

                Current content of /mnt/snapshots
                total 0
                drwxr-xr-x 1 root root 418 Mar 11 09:28 @202203110929
                drwxr-xr-x 1 root root 418 Mar 11 09:41 @202203110941
                drwxr-xr-x 1 root root 418 Mar 11 09:42 @202203110943
                drwxr-xr-x 1 root root 418 Mar 11 10:09 @202203111010
                drwxr-xr-x 1 root root 418 Mar 11 10:22 @202203111022
                drwxr-xr-x 1 root root 418 Mar 11 10:30 @202203111030
                drwxr-xr-x 1 root root 418 Mar 11 10:40 @202203111041
                drwxr-xr-x 1 root root 418 Mar 11 10:45 @202203111046
                drwxr-xr-x 1 root root 418 Mar 11 10:47 @202203111047
                drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203110929
                drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203110941
                drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203110943
                drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203111010
                drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203111022
                drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203111030
                drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203111041
                drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203111046
                drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203111047

                Incremental snapshot sub-routine variables for root will be displayed. Press any key to continue.
                Variable content for use in @ incremental snapshots

                SNAPLIST is @202203110929 @202203110941 @202203110943 @202203111010 @202203111022 @202203111030 @202203111041 @202203111046 @202203111047
                OLDESTSNAP is @202203110929
                PREVIOUSSNAP is @202203111046
                NOW is @202203111047

                Press any key to continue.
                Attempting incremental backup of @

                PREVIOUSSNAP is: @202203111046
                NOW is: @202203111047
                MKINC is: btrfs send -p /mnt/snapshots/@202203111046 /mnt/snapshots/@202203111047 | btrfs receive /backup

                At subvol /mnt/snapshots/@202203111047
                At snapshot @202203111047
                ERROR: cannot find parent subvolume

                Current content of /backup
                total 0
                Press Ctrl+C now^C
                root@barley-cat:/#

                As far as what this is saying just before the execution of the command, the incremental snapshot should be received on /backup, but as the ERROR indicates, it isn't.
                I just don't understand what is wrong. What am I missing or not seeing?
                Last edited by Snowhog; Mar 11, 2022, 12:02 PM.
                Windows no longer obstructs my view.
                Using Kubuntu Linux since March 23, 2007.
                "It is a capital mistake to theorize before one has data." - Sherlock Holmes

                Comment


                  #53
                  The parent snapshot, @202203111046, is already supposed to be on /backup because of a previous send. Is it?
                  "A nation that is afraid to let its people judge the truth and falsehood in an open market is a nation that is afraid of its people.”
                  – John F. Kennedy, February 26, 1962.

                  Comment


                    #54
                    There is nothing on /backup.

                    That prompts this question: This script doesn't send the created FULL snapshot to /backup, and neither does yours. How are you getting your created FULL snapshots to /backup? I don't see that happening in your script.

                    Is that the crux of the issue with my script; there are no @ and @home snapshots on /backup?
                    Windows no longer obstructs my view.
                    Using Kubuntu Linux since March 23, 2007.
                    "It is a capital mistake to theorize before one has data." - Sherlock Holmes

                    Comment


                      #55
                      Originally posted by Snowhog View Post
                      There is nothing on /backup.

                      That prompts this question: This script doesn't send the created FULL snapshot to /backup, and neither does yours. How are you getting your created FULL snapshots to /backup? I don't see that happening in your script.

                      Is that the crux of the issue with my script; there are no @ and @home snapshots on /backup?
                      That there are NO snapshots on /backup is why the reference to the parent snapshot fails.

                      Do this:
                      btrfs send /mnt/snapshots/@202203111046 | btrfs receive /backup
                      which will send the parent snapshot to /backup. It will take about 16 minutes.

                      Then run
                      btrfs send -p /mnt/snapshots/@202203111046 /mnt/snapshots/@202203111047 | btrfs receive /backup
                      which will work because the parent snapshot is now on /backup.
                      "A nation that is afraid to let its people judge the truth and falsehood in an open market is a nation that is afraid of its people.”
                      – John F. Kennedy, February 26, 1962.

                      Comment


                        #56
                        I want to thank everyone who has commented in this Topic. I've learned A LOT over the last several days. I finally got the script finished. I'm having another set of eyes look it over, but the first part; the creation of both @ and @home snapshots and then sending them to /backup, works. I've tested it. Right now there are exactly one @ and @home snapshots on /mnt/snapshots and /backup.

                        The incremental section of my script is written to check that at least two snapshots of @ and @home are present on /mnt/snapshots and /backup. If there are, the incremental section runs. If there are not, then it says so and exits the script. That way, I can look into it.

                        I'll post my finished script later, after it's been reviewed by the other set of eyes and it's given the "Looks good to me. I don't see any glaring errors."

                        "Surgeons don't operate on themselves, so don't try to proof read your own code!"
                        Windows no longer obstructs my view.
                        Using Kubuntu Linux since March 23, 2007.
                        "It is a capital mistake to theorize before one has data." - Sherlock Holmes

                        Comment


                          #57
                          Originally posted by Snowhog View Post
                          "Surgeons don't operate on themselves, so don't try to proof read your own code!"
                          I can't agree, but all those unnecessary "eval"s don't help.

                          Regards, John Little

                          Comment


                            #58
                            I have 'one' remaining btrfs error that I need to resolve before I'll publish my script here. I'll explain the error a bit later; I've only just gotten up, and I haven't had my requisite volume of coffee yet!
                            Windows no longer obstructs my view.
                            Using Kubuntu Linux since March 23, 2007.
                            "It is a capital mistake to theorize before one has data." - Sherlock Holmes

                            Comment


                              #59
                              I don't understand why btrfs doesn't like the command (See the error in red below).

                              This is the only error the script is generating. If I can get help on it, I can apply that to the second send/receive (@home) and the script will be done.

                              root@barley-cat:/# /snapshot.sh
                              Snapshots will be named @202203121415 and @home202203121415

                              Mounting Internal HDD
                              Command is: mount /dev/disk/by-label/LAPTOP /mnt
                              Showing /mnt

                              total 0
                              drwxr-xr-x 1 root root 250 Mar 12 14:15 @
                              drwxr-xr-x 1 root root 36 Mar 1 20:42 @home
                              drwxr-xr-x 1 root root 60 Mar 12 12:57 snapshots

                              Mounting External USB HDD
                              Command is: mount /dev/disk/by-label/USBHDD /backup
                              Showing /backup

                              total 0
                              drwxr-xr-x 1 root root 222 Mar 11 22:27 @202203112214
                              drwxr-xr-x 1 root root 36 Mar 11 22:29 @home202203112214

                              Making today's snapshot of @ on /mnt/snapshots

                              Command is: btrfs su snapshot -r /mnt/@ /mnt/snapshots/@202203121415

                              Create a readonly snapshot of '/mnt/@' in '/mnt/snapshots/@202203121415'
                              @202203121415 successfully created

                              Sending @202203121415 to /backup

                              Command is: btrfs send /mnt/snapshots/@202203121415 | btrfs receive /backup

                              At subvol /mnt/snapshots/@202203121415
                              At subvol @202203121415
                              @202203121415 successfully sent to /backup

                              Making today's snapshot of @home on /mnt/snapshots

                              Command is: btrfs su snapshot -r /mnt/@home /mnt/snapshots/@home202203121415

                              Create a readonly snapshot of '/mnt/@home' in '/mnt/snapshots/@home202203121415'
                              @home202203121415 successfully created

                              Sending @home202203121415 to /backup

                              Command is: btrfs send /mnt/snapshots/@home202203121415 | btrfs receive /backup

                              At subvol /mnt/snapshots/@home202203121415
                              At subvol @home202203121415
                              @home202203121415 successfully sent to /backup

                              Showing /mnt/snapshots

                              total 0
                              drwxr-xr-x 1 root root 222 Mar 11 22:10 @202203112214
                              drwxr-xr-x 1 root root 250 Mar 12 14:15 @202203121415
                              drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203112214
                              drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203121415

                              Showing /backup

                              total 0
                              drwxr-xr-x 1 root root 222 Mar 11 22:27 @202203112214
                              drwxr-xr-x 1 root root 250 Mar 12 14:27 @202203121415
                              drwxr-xr-x 1 root root 36 Mar 11 22:29 @home202203112214
                              drwxr-xr-x 1 root root 36 Mar 12 14:29 @home202203121415

                              Attempting incremental snapshot of @
                              Command is: btrfs send -p /mnt/snapshots/@202203112214 /mnt/snapshots/@202203121415 | btrfs receive /backup

                              At subvol /mnt/snapshots/@202203121415
                              At snapshot @202203121415
                              ERROR: creating snapshot @202203112214 -> @202203121415 failed: File exists

                              IF send/receive command FAILED, Press Ctrl+C now to Quit.

                              root@barley-cat:/# vdir /mnt/snapshots/
                              total 0
                              drwxr-xr-x 1 root root 222 Mar 11 22:10 @202203112214
                              drwxr-xr-x 1 root root 250 Mar 12 14:15 @202203121415
                              drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203112214
                              drwxr-xr-x 1 root root 36 Mar 1 20:42 @home202203121415
                              root@barley-cat:/# vdir /backup/
                              total 0
                              drwxr-xr-x 1 root root 222 Mar 11 22:27 @202203112214
                              drwxr-xr-x 1 root root 250 Mar 12 14:27 @202203121415
                              drwxr-xr-x 1 root root 36 Mar 11 22:29 @home202203112214
                              drwxr-xr-x 1 root root 36 Mar 12 14:29 @home202203121415
                              root@barley-cat:/#
                              Windows no longer obstructs my view.
                              Using Kubuntu Linux since March 23, 2007.
                              "It is a capital mistake to theorize before one has data." - Sherlock Holmes

                              Comment


                                #60
                                Showing /backup

                                total 0
                                drwxr-xr-x 1 root root 222 Mar 11 22:27 @202203112214
                                drwxr-xr-x 1 root root 250 Mar 12 14:27 @202203121415
                                drwxr-xr-x 1 root root 36 Mar 11 22:29 @home202203112214
                                drwxr-xr-x 1 root root 36 Mar 12 14:29 @home202203121415

                                Attempting incremental snapshot of @
                                Command is: btrfs send -p /mnt/snapshots/@202203112214 /mnt/snapshots/@202203121415 | btrfs receive /backup

                                At subvol /mnt/snapshots/@202203121415
                                At snapshot @202203121415
                                ERROR: creating snapshot @202203112214 -> @202203121415 failed: File exists
                                You cannot overwrite an existing snapshot using its same name, regardless of if their contents are the same or not.

                                Since you've already sent it to /backup the incremental backup cannot use the parent and create a new child because the child already exists on /backup and is read only.

                                So, why do an incremental backup if you've already sent the snapshot to /backup?
                                Last edited by GreyGeek; Mar 12, 2022, 03:25 PM.
                                "A nation that is afraid to let its people judge the truth and falsehood in an open market is a nation that is afraid of its people.”
                                – John F. Kennedy, February 26, 1962.

                                Comment

                                Working...
                                X