reflink | Cross-platform COW reflink copy of files | File Utils library

I wonder about an efficient way to copy files (on Linux, on a FS which supports copy-on-write (COW)). Specifically, I want that my implementation uses copy-on-write if possible, but otherwise falls back to other efficient variants. Specifically, I also care about server-side copy (supported by SMB, NFS and others), and also zero-copy (i.e. bypassing the CPU or memory if possible).

(This question is not really specific to any programming language. It could be C or C++, but also any other like Python, Go or whatever has bindings to the OS syscalls, or has any way to do a syscall. If this is confusing to you, just answer in C.)

It looks like ioctl_ficlonerange, ioctl_ficlone (i.e. ioctl with FICLONE or FICLONERANGE) support copy-on-write (COW). Specifically FICLONE is used by GNU cp (here, via --reflink).

Then there is also copy_file_range, which also seems to support COW, and server-side-copy. (LWN about copy_file_range.)

It sounds as if copy_file_range is more generic (e.g. it supports server-side-copy; not sure if that is supported by FICLONE).

However, copy_file_range seems to have some issues. E.g. here, Paul Eggert comments:

[copy_file_range]'s man page says it uses a size_t (not off_t) to count the number of bytes to be copied, which is a strange choice for a file-copying API.

Are there situations where FICLONE would work better/different than copy_file_range?

Are there situations where FICLONE would work better/different than FICLONERANGE?

Specifically, assuming the underlying FS supports this, and assume you want to copy a file. I ask about the support of these functions for the functionality of:

• Copy-on-write support
• Server-side copy support
• Zero-copy support

Are they (FICLONE, FICLONERANGE, copy_file_range) always performing exactly the same operation? (Assuming the underlying FS supports copy-on-write, and/or server-side copy.)

Or are there situations where it make sense to use copy_file_range instead of FICLONE? (E.g. COW only works with copy_file_range but not with FICLONE. Or the other way around. Or can this never happen?)

Or formulating the same question differently: Would copy_file_range always be fine, or are there situations where I would want to use FICLONE instead?

Why does GNU cp use FICLONE and not copy_file_range? (Is there a technical reason, or is this just historic?)

Related: GNU cp originally did not use reflink by default (see comment by the GNU coreutils maintainer Pádraig Brady). However, that was changed recently (this commit, bug report 24400), i.e. COW behavior is the default now (if possible) (--reflink=auto).

Related question about Python for COW support.

Related discussion about FICLONE vs copy_file_range by Python developers. I.e. this seems to be a valid question, and it's not totally clear whether to use FICLONE or copy_file_range.

Related Syncthing documentation about the choice of methods for copying data between files, and Syncthing issue about copy_file_range and others for efficient file copying, e.g. with COW support. It also suggests that it is not so clear that FICLONE would do the same as copy_file_range, so their solution is to just try all of them, and fallback to the next, in this order: ioctl (with FICLONE), copy_file_range, sendfile, duplicate_extents, standard.

Related issue by Go developers on the usage of copy_file_range. It sounds as if they agree that copy_file_range is always to be preferred over sendfile.

(Question copied from here but I don't see how this is too less focused. This question is very focused and asks a very specific thing (whether FICLONE and copy_file_range behave the same), and should be extremely clear. I formulated the question in multiple different ways, to make the question even more clear. This question is also extremely well researched, and should already be very valuable to the community as-is with all the references. I would have been very happy if I would have found such a question by itself, even without answers, when I started researching about the differences between FICLONE and copy_file_range.)

Hi guys I would like to ask for some help with my bash script. I am running 2 python script inside my bash script and it is working when I'm running it manually but when I'm using cron only the commands in the .sh file is working not on .py

Please take note that I already install necessary utils and packages for python3.

This is the script:

I need help with making the XFS quotas work in Kubernetes on DigitalOcean.

My problem essentially is that the xfs_quota tool seems to work only when one has also an access to the disk device, not only to the mounted volume. However, whatever I try, I can't seem to get access both to the device and the mount.

I tried both volume mounts and raw block volumes.

Here's my storage class:

I tried to build a personal blog using Github page and hexo. I am using matery theme. However, brackets in the code area cannot be displayed correctly in hexo blog. Instead, it is shown {. I am not sure what changes I made. The code now looks like this.

Trying to make a Perl script to open an HTML file and extract anything contained within tags.

Sample HTML:

I want to be able to copy "reflink" on a button click with a tooltip to pop up after "reflink" was copied

This is my code

i would like to scrape a specific bit of html-code out of a website. The desired object isn't on every page of the loop below, therefore, some values are NA. But whenever an object is missing, the whole loop stops.

I tried this code for non-loop scraping, which turned out to work perfectly. Here i excluded all values that are either unobtainable or not of interest.

BJ <- data.frame( Wohnungs_ID = ID, Baujahr = ifelse (nchar(Baujahr)==0 | nchar(Baujahr)>6, NA, Baujahr), stringsAsFactors = F

In the relevant case, i want to scrape two specific variables, that are not always listed. Url is the list of reflinks i scraped ealier.

I need to use a proxy with htmlagilitypack. I give a link to my app RefURL . After that I want the app get url from a proxy address . for instance "101.109.44.157:8080"

I searched and found out this:

I'm learning about in-kernel data transferring between two file descriptors in Linux and came across something I cannot understand. Here is the quote from copy_file_range manpage

copy_file_range() gives filesystems an opportunity to implement "copy acceleration" techniques, such as the use of reflinks (i.e., two or more i-nodes that share pointers to the same copy-on-write disk blocks) or server-side-copy

I used to think of index nodes as something that is returned by stat/statx syscall. The st_ino type is typedefed here as