|
|
| --absoluteAbsolute Symbolic Links |
The target of a symbolic link can either be a fully qualified path starting at the root of a drive, e.g e:\data\cpp\myfile.txt also fully qualified path but pointing to a volume, e.g. \\?\Volume{f6c8b244-1ce4-11e0-a607-005056c00008}\ or can be be specified relatively, e.g ..\..\data\cpp\myfile.txt ln.exe by default tries to create relative target path names for symbolic links as long as this is possible, e.g the file and its target are on the same logical drive. Having relative symbolic link targets is much smarter especially when the target of links is in the same directory. If a symbolic link and its target are on different drives, ln.exe uses absolute pathnames. If the creation of absolute target pathnames should be forced use the --absolute option. ln --absolute --symbolic Sourcefile.txt Destination.txt In the above example Sourcefile.txt gets linked to Destination.txt with an absolute target path. ln --absolute --symbolic Sourcefile.txt DestinationDirectory In the above example a symbolic link DestinationDirectory\Sourcefile.txt gets linked to Sourcefile.txt with an absolute target path. ln --absolute --symbolic SourceDirectory DestinationDirectory In the above example a symbolic link directory SourceDirectory gets linked to DestinationDirectory with an absolute target path. ln --absolute --symbolic SourceDirectory DestinationDirectory\ In the above example a symbolic link directory DestinationDirectory\SourceDirectory gets linked to SourceDirectory with an absolute target path. A traling backslash is the trigger for this to work. |
|
|
| --anchorSupply Anchor Paths |
This option can be used together with other options like --copy and it supplies a virtual path or an anchor to the e.g copy process, so that junctions and absolute symbolic links can be restored properly in the destination even if they would be outer junctions/symbolic link. Think of the following task to be solved: For some unknown reason the system can't be booted from c:\ anymore The system is booted from an external media, and your former drive c:\ is now available as e.g. e:\ The whole drive should be copied from e:\ to y:\ ( Because you put a fresh disc into y:\ ) Drive y:\ should afterwards replace your old c:\ and you would like to boot from it. Most important: All junctions and symbolic links should be alive after this operation. Your situation with respect to junctions and symbolic links is like this:  There are absolute junction/symbolic links in your structure, which point to c:\ but with respect to its new root e:\ all junctions pointing to c:\ are now outer junctions/symbolic link. A normal --copy would simply crop these junctions, which is unwanted, because the whole disk should be recovered as much as possible. The solution is to broaden the scope for ln.exe to decide if it is an outer or inner junction by supplying additional anchor path to the copy process. ln --anchor c:\ --destination c:\ --copy e:\ y:\ The above example supplies c:\ as additional anchor path and lets ln.exe assume that all junctions and symbolic links below e:\, which point to some places below c:\ are inner junctions, and thus are restored in the destination as junctions/symbolic links pointing to places below c:\ properly. The option --destination is needed because the inner junctions found on e: shall point to c: even if the destination of this copy operation is y:\ But in real life situations are more complex : The original c:\ drive might also have junctions to e.g. d:\ e:\. To also adress this do the following: Mount your drive to be copied to some drive letter, where no junctions point to. In the above example f:\ would be fine Use --anchor for each drive where you know junctions from former c:\ point to. ln --anchor c:\ --destination c:\ --anchor d:\ --destination d:\ --anchor e:\ --destination e:\ --copy f:\ y:\ The order of --anchor and --destination in the above example is important: They build kind of pairs. Copying a full drive The full black magic on copying with permissions a whole drive also includes the --backup switch ln --backup --anchor c:\ --copy e:\ y:\ Adding --backup also copies all permissions, streams and the like. Or you omit --backup and only use --keepsymlinkrelation. The --anchor options is also useful when working with snapshots, because snapshots can be mapped either as different drive or as UNC path. Both ways causing the problem of junctions within snapshots to be recognized as outer junctions and thus beeing cropped. Mirroring a drive If a system drive should be backuped regularly and data, which have been already copied in the run before, should not be copied, then go for: ln --backup --anchor c:\ --mirror e:\ y:\ If this should be done via snapshots, see Copying a whole drive via snapshots. The above example does not use --destination. This means the inner junctions/symbolic links, which point to c: on the source now in the destination y: point to y: See also the note on quotes. |
| --backupBackup Mode |
Using the Backup Mode ACLs aka Access Control Lists, which contain the security for Files, Folders, Junctions or SymbolicLinks, and Encrypted Files are also copied. ln.exe thus copies Alternative Streams on files and folders EA Records on files and folders (rarely used) Reparse Info File Attributes Timestamps: Creation Time, Last Access Time, Last Write Time Sparse Files and Alternative Sparse Streams Encrypted files ACLs The --backup switch is a modifier to all other operations like e.g --copy, --mirror or --delorean. ln --backup --copy x:\SourcePath x:\DestinationPath All files with all the above mentioned attributes are copied from x:\SourcePath to x:\DestinationPath The --backup mode automatically enables the --keepsymlinkrelation modifier. |
| --copySmart Copy |
Smart Copy basically creates a copy of the directory structure from the source location to the destination, but it preserves the inner hardlink structure and inner junction/symbolic link relations of the source, and recreates this inner hardlink structure and inner junction/symbolic link relation at the destination location: With hardlinks it behaves as follows:  By closely looking at the above picture one can find three different types of files: Normal Files The file B is a normal file. It gets copied as any other copy tool would do. Saturated Hardlinks The files E and F are hardlinked together. In ln.exe terms they are called Saturated Hardlinks, because the reference count, which is here 2, matches the number of occurrences below 'Folder 1', which is here 2. In General: A hardlink is called Saturated with respect to a folder F, if the number of occurrences below the folder F matches the reference count. Saturated Hardlinks can be copied completely via Smart Copy. Unsaturated Hardlinks The Files A, C, D are hardlinked together. In ln.exe terms they are called Unsaturated Hardlinks, because the reference count, which is here 3, does not match the number of occurrences below 'Folder 1', which is here 2. Only C and D are below Folder 1. In General: A hardlink is called Unsaturated with respect to a folder F, if the number of occurrences below the folder F is smaller than the reference count. Unsaturated Hardlinks can only be partially copied by Smart Copy. In the above example C and D are hardlinked together in the destination location, but the hardlink to A is broken. This means that the reference count of C and D is 2 in the destination location. With junctions or symbolic link directories the default behaviour during smartcopy is as follows:  By closely looking at the above picture one can find three different types of folders/junctions: Normal Folders The folder 'Folder 3' is a normal folder. It gets copied with its content as any other copy tool would do. Inner JunctionsSymlinks The folder 'Inner Junction/Symlink' is targeted at 'Inner Junction/Symlink Target'. In LSE terms this kind of folder is called Inner Junction/Symlink, because its target points to a folder, which is below the common anchor 'Folder 1'. Inner Junctions/Symlinks are restored properly via Smart Copy in the destination location. Outer JunctionsSymlinks The folder 'Outer Junction/Symlink' is targeted at the folder 'Outer Junction/Symlink Target'. In ln.exe terms this kind of folder is called Outer Junction/Symlink, because its target points to a folder, which is in parallel and thus outside the anchor 'Folder 1'. Outer Junctions/Symlinks can be handled in three different ways. Please see the section on Outer Junction/Symlink Handling. Symbolic Links to files behave as follows during Smart Copy:  By closely looking at the above picture one can find three different types of files/symbolic links: Normal Files The file A is a normal file. It gets copied as any other copy tool would do. Inner SymbolicLinks The symbolic link 'Inner Symlink' is targeted at 'Inner Symlink Target'. In LSE terms this kind of symbolic link is called Inner Symlink, because its target points to a file, which is below the common anchor 'Folder 1'. Inner Symlinks are restored properly via Smart Copy at the destination location. Outer SymbolicLinks The symlink 'Outer Symlink' is targeted at the folder 'Outer Symlink Target'. In LSE terms this kind of symbolic link is called Outer Symlink, because its target points to a file, which is in parallel and thus outside the anchor 'Folder 1'. Outer Symlinks are handled by Smart Copy depending on the Outer Junction/Symbolic Link handling. e.g.: ln --copy x:\dir\dir2 y:\dir\newdir In the above example the directories and files below x:\dir\dir2 are copied to y:\dir\newdir, and all hardlinks/junctions/symbolic links within x:\dir\dir2 are copied/tied to their new locations under y:\dir\newdir. The --copy operation only copies if the files in the destination are either not there, or if the files in the source are newer. Otherwise the item is skipped. See also the note on quotes. If you use ln.exe as a backup tool with the --copy option, please make sure you test that everything is copied. I tested ln --copy many times, and had no problems, but when it comes to backing up data, one has to be careful. Smart Copy is a must if e.g. the whole content of a hard disk, which has lots of hardlinks/junctions/symbolic links, should be copied to another hard disk. During the Smart Copy operation empty folders get copied too and the time stamps of folders/junctions/symbolic links are also restored at the corresponding destination locations. Because Smart Copy creates inner hardlinks/junctions/symbolic links, this feature is only available on NTFS volumes. Smart Copy also processes all available alternative NTFS streams, EA Records, Sparse Files of a file. To also copy the ACLs, see the Backup Mode Output See Output among Delorean Copy for a detailed description of Smart Copies output. Shell Integration The Copy or Smart Copy functionality is also available via Link Shell Extension |
| --cropCrop/Unroll/Splice Outer Junctions/Symbolic Links |
During SmartCopy, Smart Mirror,Delorean Copy and Clone so called Outer Junctions/Symlink directories may need processing. There are 3 different ways to deal with those Outer Junctions/Symlink directories: Crop Crop breaks links to Outer Junctions/Symlink directories in the destination. Crop also applies to Outer Symlink Files.  In the above example Folder1 is copied to Destination/Folder1, but_Outer Junction/Symlink_ is not available in the destination, because Folder1/Outer Junction/Symlink pointed to Folder0/Outer Junction/Symlink Target, which is not below Folder1. The objective behind cropping Outer Junctions/Symlink Directories is to get a pure copy during Smart Copy, Smart Mirror, Delorean Copy and Clone without connections to the source. Crop is the default behaviour of ln.exe, e.g.: ln --copy "c:\Folder 1" "c:\Destination\Folder 1" Unroll Unroll follows Outer Junctions/Symlink Directories and rebuilds the content of Outer Junctions/Symlink Directories inside the hierarchy at the destination location. Unroll also applies to Outer Symlink Files, which means, that unroll causes the target of Outer Symlink Files to be copied to the destination location.  In the above example Folder1 is copied to Destination/Folder1, and_Outer Junction/Symlink_ and all the files/directories below Outer Junction/Symlink Target are copied to the folder Outer Junction/Symlink in the destination. The objective behind unrolling Outer Junctions/Symlink Directories is to get everything with which the source is connected and rebuild it as separate copy in the destination. It resembles the 'hair of the elephant' pattern: Pull on a hair of an elephant, and get the whole elephant. The command line invocation below unrolls all junctions/symbolic link directories below "c:\Folder 1" ln --unroll --copy "c:\Folder 1" "c:\Destination\Folder 1" In certain situations only certain junctions/symbolic link directories should be unrolled during SmartCopy, DeloreanCopy, SmartMirror or HardlinkClone. To accomplish this ln.exe can be run with wildcard expressions to specify certain directories for unrolling. ln --unroll "MyJunc*" --copy "c:\Folder 1" "c:\Destination\Folder 1" To specify junctions/symbolic link directories for unrolling more fine grained regular expressions can be given: ln --unrollregexp "[a-z]*" --copy "c:\Folder 1" "c:\Destination\Folder 1" The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax. They are not casesensitiv. The regular expression specified under --unrollregexp is applied to the whole source path: ln --unrollregexp "Folder 1\\MyJunc*" --copy "c:\Folder 1" "c:\Destination\Folder 1" In this example only Outer Junctions/Symbolic Link Directories, matching "Folder 1\\MyJunc*" are unrolled. Please make sure that the back slash \ is escaped by a double \\ as shown in the above example. Advanced thoughts on Unrolling The picture above was just the simplest case, because Unroll does much more when it encounters complex situations. Think of an outer junctions/symbolic links, which itself contains junctions/symbolic links, which are inner with respect to the first outer junction symbolic link:  In the above example Folder1 is copied to Destination/Folder1, and_Outer Junction/Symlink_ and is unrolled as expected, but since Junction/Symlink is an inner junction with respect to Outer Junction/Symlink Target, the junction/symlink relation is restored in the destination. This kind of nesting can be much more complex:  In the above example Folder1 is copied to Destination/Folder1, and_Outer Junction/Symlink_ and is unrolled as expected, but then it starts to get fascinating, because we have two levels of outer junctions/symlinks which all have respective inner junctions/symlinks, and which are restored properly. Once you have followed through the above picture, you got it. It is not simple I know, but it is necessary to properly unroll. And complexity increases if symbolic link files are within unrolled outer junctions/symbolic links:  In the above example Folder1 is copied to Destination/Folder1, and_Outer Junction/Symlink_ and is unrolled as expected, but it contains Inner Outer Symlink which points to Inner Outer Symlink Target and this is an inner junction/symbolic link with respect to Outer Junction/Symlink Target But worth mentioning is the Symbolic Link Outer Symlink, which would be a definitive outer symbolic link, but since its targets parent-directory Outer Junction/Symlink Target is unrolled, Outer Symlink becomes an inner symbolic link with respect to Folder1. File1 Symlink is also an outer symbolic link, but its target parent-directory_Folder2_ is not that lucky to get unrolled, so in the destination File1 Symlink is not a symbolic link any more, but a copy of the symbolic links' target. Nested Reparse Points are also an interesting use case, which the algorithm has to tackle with:  In the above example Folder1 is copied to Destination, and_Junction/Symlink F0_ and is unrolled as expected, but it contains inner nested reparse points. Nested means Reparse point pointing to Reparse Points The Unroll functionality also opens up the possibility to have circular Junction/Symbolic Link relations among a set of copied items:  In the above example Folder1 is copied via the --unroll option to Destination/Folder1. Smart Copy/Smart Mirror and Delorean Copy operations can deal with the above shown circularities and break circularities by not following the affected Junction/Symbolic Link. Junctions/Symbolic Links can also point to FAT drives or other NTFS drives requiring as a prerequisite unique Disk-IDs on all disks, which are chained together via Junctions/Symbolic links:  Hardlink siblings are found by matching the per NTFS volume unique file-id, but if more volumes are chained together it might happen that the same file-ids can be found on two different NTFS volumes. To address this all operations use the disk-id and the file-id to match hardlink siblings. Furthermore it is not allowed to have the disk-id 0xFFFF-FFFF, because the algorithms use this as internal indicator of a FAT drive. The Unroll option also allows to point multiple junctions to point to the same target location, which causes the algorithms to traverse the same items many times:  At the first glance multiple traversing of items looks simple, but for files this means that multiple traversed files are the same in the destination and are hardlinked together. So don't be confused when you see hardlinks, which have never ever been there before. Copying Junction/Symbolic Links from mapped network drives also needs extra care, because junctions on the remote machine relate with path references only valid on the remote machine to each other:  The example in the above picture shows such a situation X:\Src\Foo\Junction/Symlink is a junction on a Remote Machine, which points to X:\Src\Foo\Folder. It is a valid Junction. X:\Src\Foo is sharded via \\RemoteMachine\MyShare, which still is no problem. \\RemoteMachine\MyShare mapped to T:\ on a local machine is fine, but the Junction T:\Junction/Symlink, if asked for its target, will still return X:\Src\Foo\Folder even on the Local Machine. One could expect that the target is T:\Folder, but it is not for Junctions. When SmartCopy/Mirror/Delorean comes across such a situation, it translates the Junction correctly when it is copied onto the Local Machines drive Y:\, so that the final Junction target points correctly to Y:\Dest\Bar\Folder This option supports taking its arguments from file. ln --unroll @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a matching pattern. e.g. MountPointTheDirectoryDirectory with blanks Splice Splice reconnects Outer Junctions/Symlink directories in the destination to their original targets.  In the above example Folder1 is copied to Destination/Folder1, and_Outer Junction/Symlink_ is available in the destination as junction, which points to the original location Outer Junction/Symlink Target. The objective behind splicing Outer Junctions/Symlink Directories to its original location is to get a copy during smartcopy, but to reuse Outer Junctions/Symlink Directories source locations. The command line invocation below splices all junctions/symbolic link directories below "c:\Folder 1" ln --splice --copy "c:\Folder 1" "c:\Destination\Folder 1" In certain situations only certain junctions/symbolic link directories should be spliced during SmartCopy, DeloreanCopy, SmartMirror or HardlinkClone. To accomplish this ln.exe can be run with wildcard expressions to specify certain directories for splicing. ln --splice "MyJunc*" --copy "c:\Folder 1" "c:\Destination\Folder 1" To specify junctions/symbolic link directories for splicing more fine grained regular expressions can be given: ln --spliceregexp "[a-z]*" --copy "c:\Folder 1" "c:\Destination\Folder 1" The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax. They are not casesensitiv. The Splice functionality is also useful, when mountpoints should be copied. Mountpoints are very similar to Junctions, but point to a path always starting with \\?\VolumeGuid.  To specify a certain mountpoint to be copied specify it as argument to --splice: ln --splice "Mountpoint" --copy "x:\Folder 1" "x:\Destination\Folder 1" In the above example Folder1 is copied to Destination/Folder1 and the_Mountpoint_ is created in the destination as Mountpoint again. It points to the original location under \\?\Volume{b4..bc}. Or drive complexity up one level and just use splice for mountpoints with wildcards, but unroll the rest. ln --unroll --splice "Mountpo*" --copy "x:\Folder 1" "x:\Destination\Folder 1" This option supports taking its arguments from file. ln --splice @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a matching pattern. e.g. MountPointTheDirectoryDirectory with blanks |
| --deleteDeLorean Delete |
In general deleting files seems so simple, but when taking a closer look at the delorean copy use case, things get interesting: Creating and keeping many Delorean Copies in a Delorean Set is something which is fairly simple, and even when it comes to deleting a specific Delorean Copy from a Delorean Set it is easy. Simply press delete in Explorer, or use the --delete option from ln.exe:  ln --delete x:\Bkp2 In the above example the directories and files below x:\Bkp2 are deleted. But wait! It is that easy if a Delorean Copy contains no files with ReadOnly attributes. Otherwise it's getting sophisticated:  A Source was used to create three successive Delorean Copies: Bkp1,Bkp2,Bkp3. File B is ReadOnly in the Source and in all Delorean Copies. So far so good. When it comes to delete Bkp2 the Readonly attribute of Bkp2/B has to be removed, otherwise deletion is impossible. Due to the fact that all siblings of a hardlink share the same attribute and the same date, the readonly attributes of Bkp1/B and Bkp3/B are also 'changed'. This is shown via the blue dotted lines. Called it 'Hardlink Attribute Teleportation' This results now in having a different attribute in Bkp1/B and Bkp3/B than in Source/B. This is shown via the grey dotted line. A fourth delorean copy with Source and Bkp3 as Backup to Bkp4 is created. Since the attributes of Bkp3/B and Source/B are different, the file Bkp4/B was copied over freshly from Source/B. So there is no hardlink between Bkp3/B and Bkp4/B, which is shown with the light red dotted line, and which is the basic problem. So how to overcome this: Before deleting Bkp2/B retrieve at least one hardlink sibling, e.g. Bkp1/B Delete Bkp2/B Restore the attribute of Bkp2/B to one hardlink sibling, which has been retrieved in 1. e.g. Bkp1/B and rely on Hardlink Attribute Teleportation, so that it spreads to all other siblings. Basically this is what the --delete option does. |
| --deloreanDeLorean Copy |
DeLorean Copy is a way of creating incremental backups by using a combination of Hardlink Clone and SmartMirror. The following picture gives an overview of what DeLorean Copy is about  In general a DeLorean Copy has 3 principals: Source(t), InitialBackup and Backup(n), where t represents time and n the number of backups. Phase 1: Initial SmartCopy The folder Source(t) is initially copied to InitialBackup. This is shown by the blue arrow. Changeshappen During this phase the files under source change, and Source(t) becomes Source(t+1). Phase 2: Hardlink Clone The folder InitialBackup is Hardlink Cloned to Backup1, which ties InitialBackup and Backup1. This is shown by the red arrow. Phase 3: Mirror Mirror the folder Source to Backup1. This is shown by the green arrow: Keep unchanged files as hardllinks to InitialBackup. Delete files no longer in Source(t+1) from Backup1. Copy different files from Source(t+1) to Backup1. With completion of this first round Backup1 contains the first lean and mean copy of Source only consisting of either hardlinks to InitialBackup, or of copied files if there was the need to copy them over from Source(t+1) because they were newer under Source(t+1). The point is that all files in Backup1 are transparently accessible, but little space is used, because not all files in the Source(t+1) changed, so that there was only the need to effectively copy over a few files from Source(t+1) to Backup1. The time stamps for LastWriteTime, CreationTime and LastAccessTime of files/folders/junctions/symbolic links are also restored at the corresponding destination locations during DeloreanCopy. Different items means: Either the file size has changed, or the LastWriteTime has changed. This can be repeated on and on. The second round would be using Source, Backup1 and Backup2 for DeLorean Copy: Changeshappen During this phase the files under source change, and Source(t+1) becomes Source(t+2). Phase 2: Hardlink Clone The folder Backup1 is Hardlink Cloned to Backup2, which ties Backup1 and Backup2. This is shown by the red arrow. Phase 3: Mirror Mirror the folder Source(t+2) to Backup2. This is shown by the green arrow: Keep unchanged files as hardllinks to Backup1. Delete files no longer in Source(t+2) from Backup2. Copy different files from Source(t+2) to Backup2. A real word example looks like this: ln --copy x:\dir\Source x:\dir\InitialBackup This creates the initial Backup as shown above in Phase 1 ln --delorean x:\dir\Source x:\dir\InitialBackup x:\dir\Backup1 This command does the first round of DeLorean copy as shown above in Phase 2 and Phase 3 creating a backup. ln --delorean x:\dir\Source x:\dir\Backup1 x:\dir\Backup2 This command creates another set of incremental DeLorean copy as shown above in Phase 2 and Phase 3 creating another backup. See also the note on quotes. Logging The logging generated by DeLorean Copy/Smart Copy/Smart Clone/Smart Mirror looks like e.g.: -f c:\backup\test\deleteme.dat=d c:\backup\test\directorygone+f c:\data\test\1.dat+f c:\data\foo\3.dat*h c:\data\foo\Hardlink of 3.dat*h c:\data\foo\Another Hardlink of 3.dat.h c:\data\already\x.dat*h c:\data\already\Hardlink of x.dat~f c:\data\failed\DidntMatch--splice.txt!?f (0x00000002) c:\data\failed\AccessDenied.txt Delorean Copy logs each action it did, and prefixes two characters to each item which it processed for each line of output. The first column of the output contains the Operation which was performed, and the second column specifies the_Type_ of item which was processed. Operation Description = Item is already present in the target. Used during Smart Mirror + Copy/Create an item. Used during Smart Copy * Hardlink a file . Item is already present in the target and is used as the source of a newly created hardlink. - Remove an item from the target that is not present in the source. Used during Smart Mirror ? Enumerate an item. ~ Item has been excluded by command line arguments. # Item has been cropped due to being an outer junction/symlink. & Junction or Symbolic Link has been re-created but turned out to be dangling in the destination. \ Opening a file. / Map file into address space. ° Hardlinks have been merged. °~ Hardlinks were not merged, because the hardlink reference count of 1023 was exceeded. °= Hardlinks were not merged, because the were already hardlinked. ! An error happened. The value in brackets is the system error code ' Informal message. Item Description f A File is processed. h A Hardlink is processed. s A Symbolic link file or Symbolic Link Directory. j A Junction is processed. m A Mountpoint is processed. d A Directory is processed. t An Alternative Stream is processed. e An E/A Record is processed. p A Sparse file is processed. Sample Description +f c:\data\myfile.txt A normal file is copied. *h c:\data\hardlnk.txt c:\data\hardlnk.txt is hardlinked to c:\data\myfile.txt. +s d:\dest\symlink.txt A Symbolic link has been created. +j d:\dest\junc01 A Junction has been created. +d d:\dest\mydir A Directory has been created. -f d:\dest\delfile The file d:\dest\delfile has been removed during e.g. Smart Mirror. -j d:\dest\junc02 The Junction d:\dest\junc02 has been removed. +m d:\dest\mountpoint The mountpoint d:\dest\mountpoint has been created during e.g. Smart Copy. =d d:\dest\mydir The directory d:\dest\mydir is the same as in the source. =s d:\dest\symlink The symlink d:\dest\symlink is the same as in the source. .h d:\dest\file.txt means that the name of this file is only printed, because some hardlinks have been newly tied to it. The file itself is already in the backup available, but the files following it are prefixed with * and are the newly tied hardlinks. *h d:\dest\new_hlink If the line above is prefixed with . it means that d:\dest\new_hlink is tied to e.g. the already existing file d:\dest\file.txt. ~d d:\source\mydir The directory d:\source\mydir has been excluded intentionally by e.g. --exclude. ~f d:\source\aFile The file d:\source\aFile has been excluded intentionally by e.g. --exclude. Items are also listed with ~ if the --unroll option is not used and outer Junctions or Symbolic Links are cropped. #d d:\source\outerreparse The junction/symlink d:\source\outerreparse has been excluded because it was an outer junction/symlink. &d d:\dir\danglingreparse The Junction or Symbolic Link d:\dir\danglingreparse has been restored, but it turned out that it is dangling in the destination. !-d (0x00000002) d:\source\aFile The ! operator indicates that there was an error. It is followed by the operation, the item which was processed and an Win32 error code. !?d (0x00000005) d:\src\deny The ? operator means the current operation was unable to enumerate all available files. It is always prefixed with ! to signal that during enumeration of items something went wrong. !+f (0x000003e7) d:\v\v.tc The ERROR_SWAPERROR means, that errors occurred during reading of a file. e.g. caused by unplugging the network cable. !*h (0x00000585) d:\ The error INVALID_INDEX aka 0x0585 means that the NTFS implementation of this drive is broken. It returns the same file-index for files with different file size. This is only a warning and ln.exe continues but ignores the retrieved file-indices. See also --dupemerge !+e (0x000000005) d:\test\A The error ERROR_ACCESS_DENIED with !+e means EA Records could not be copied. This happens if a filesystem does not support EA Records, as it is with some NAS implementations. !+t (0x00000007b) d:\test\A:ADS1 The error ERROR_INVALID_NAME aka 0x007b with !+t means an Alternative Data Stream of a file could not be copied. This happens if a filesystem does not support Alternative Data Streams, as it is with some NAS implementations. !+s (0x00000013d) t:\f3\f3_j0 The error ERROR_MR_MID_NOT_FOUND aka 0x007b with !+s means that the driver for symbolic links under Windows XP was not able to resolve a symbolic link on a mapped network drive. This is a technical limiation, which can't be overcome as the author of the driver Masatoshi Kimura explained, because to resolve a symbolic link via network one has to send the symbolic link target to the server, which hosts the network connection. Since SMBv1, which is available on WindowsXP is not able to transport this string, it is impossible to resolve a symbolic link on network drives. a problem. It stops in resolving with the error code STATUS_STOPPED_ON_SYMLINK. I stumbled accross that message when ln.exe tried to follow symbolic links on mapped network drives. Since the symbolic link driver is not maintained anymore by his author... Sorry! !+r (0x00001129) d:\src\invalid_reparse Windows supports a dozen of Reparse Points. Well known is the use of reparse points for symbolic links, junctions and mountpoints, but there area lot more which are not supported by ln.exe because the data contained in the reparse point is undocumented or proprietary. ln.exe copies the file referenced by such a reparse point only when used with the --unroll option, otherwise the error message ERROR_REPARSE_TAG_INVALID aka 0x1129 is printed. !+h (0x00000476) d:\src\toomanylinks NTFS puts a 1023 limit on the number of hardlinks for one item. If ln runs into the problem, that the 1024th hardlink on an item should be created, it throws the ERROR_TOO_MANY_LINKS message aka 0x00000476.See also !°f (0x0000xxxx) d:\src\file2merge If a file can not be accessed during merge of .e.g two delorean sets this message along with the error code is thrown.See also 'Entering on the fly dupemerge ln.exe was forced into on the fly dupemerge mode. 'Sleeping %d sec: Destination is a remote drive There is an issue with SMB2 Redirector Caches, where ln.exe needs to wait during Delorean Copy for about 5 seconds until it can continue. The point here is that ln.exe creates a hardlinks on a SMB2 drive, Windows Reports everything is fine, one can list the hardlinks, but as soon as one opens the hardlink within the time specified in HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Lanmanworkstation\Parameters an ERROR_FILE_NOT_FOUND (0x02) will be returned. To overcome this ln.exe waits for the time specified in HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Lanmanworkstation\Parameters. Statistics After DeLorean Copy is finished it displays a statistics like this: Total Copied Linked Skipped Removed Excluded Failed Folder: 10 1 - 6 1 3 0 File: 1050 1026 4 0 3 0 20 Junction: 7 - 2 0 2 3 0 Symlink: 8 - 2 5 1 0 1 Byte: 458200 272600 185600 0 1392 0 0 Overall Clone Mirror Times: 00:00:02.621 00:00:02.559 00:00:00.062 The statistics of DeLorean Copy only counts the operations which are performed during the Mirror phase between Source and Backup(n+1). The operations which are performed during cloning between Backup(n) and Backup(n+1) are not counted in the final DeLorean Copy statistics. Total: The total number of items as they were found under the Source. Total is the sum of all other columns but the Removed column. Copied: Items prefixed with + in the verbose output and which were were copied from Source to Backup Items prefixed with & in the verbose output and which have turned out to be dangling Junctions or Symbolic Links in the Backup Linked: Items prefixed with * in the verbose output which were either hardlinks or Items prefixed with + in the verbose output which were symbolic links Skipped: Items prefixed with = in the verbose output, which were skipped during copy, because they were already there Removed: Items prefixed with - in the verbose output, and which were removed from Backup because they are not in the Source any more. Excluded: Items prefixed with ~ in the verbose output and which were excluded from Backup, because they were excluded from the Source via --exclude. Items prefixed with # in the verbose output, because --splice/--unroll was specified with a regular expression, but the regexp didn't match. Items prefixed with # in the verbose output, because no --unroll or --splice was given at all, thus it wascropping. Failed: The number of items which failed during creation. The number of items which failed during cleaning while doing SmartMirror and while doing Delorean Copy. Overall: Time used up for the whole DeLorean Copy including the Clone from_Backup(n)_ to Backup(n+1) and the Mirror from Source to Backup(n+1) Clone: Time used up for the Clone from Backup(n) to Backup(n+1) Mirror: Time used up for the Mirror from Source to Backup(n+1) Limitations It is little known, but NTFS has a limit to create a maximum of 1023 hardlinks to one file. For DeLorean Copy this means that it will display an error message if this limit is exceeded, because exceeding this limit means loss of data among the most recent backup sets: Delorean Copy FAILED! The NTFS link limit of 1023 has been exceeded for: The reason for exceeding this limit could either be, that there have been more than 1023 backup sets but no hardlinks within the Source, or there are hardlinks within the Source and less than 1023 backup sets.See also The filters of --includeXXX or--excludeXXX are applied in the source and the destination location Shell Integration DeLorean Copy functionality is also available via Link Shell Extension Anchor and Destination DeLorean Copy might need --anchor and/or --destination if there are inner junctions / symbolic links among the source and the source dir is not referenced via its native name (e.g. X:\path ), but via UNC Shares or GLOBALROOT / Volumeguid due to operation via snapshotservice |
|
|
| --destinationSpecify Destination |
In general ln.exe operates on source/target pairs. The default pair is always provided via e.g. --copy SourceDir TargetDir, or --mirror SourceDir TargetDir --anchor AnchorDir provides an extra pair, but without --destination it uses the current target as second part of the pair .e.g --anchor AnchorDir --copy SourceDir TargetDir creates two pairs SourceDir/TargetDir AnchorDir/TargetDir To modify the pair AnchorDir/TargetDir one must provide --destination: --anchor AnchorDir --Destination DestinationDir --copy SourceDir TargetDir so that the pairs now are SourceDir/TargetDir AnchorDir/DestinationDir The --destination option can only be used in combination with the --source option, or the --anchor option |
|
|
| --dupemergeOn the fly Dupemerge |
Smart Copy, Smart Mirror andSmartClone rely on finding the hardlink relations by enumerating the unique file-index attribute of each file. But there might be more equal files below a given path, some of them probably not hardlinked. When issuing the --dupemerge option ln.exe does not only rely on the file-indices, but also creates incremental hash sums on all files, so that it finds additional not yet hardlinked dupes and hardlinks them in the destination:  e.g.: ln --dupemerge --copy Folder1 Destination\Folder1 In the above example the directory Folder1 is searched for dupes and copied/hardlinked to destination. The files A, C, D are already hardlinked in the source, but B is not, even if it is the same as A,C,D. Similar situation with E,F, which are already hardlinked, but G is the same as E,F but not hardlinked. In the destination all equal files are hardlinked: There is a dupel B,C,D and a dupel E,F,G. A was omitted as in normal Smartcopy, because it is out of the source scope. Broken NTFS implementations The --dupemerge option is also of help, when data from a drive should be copied which has a broken NTFS implementation. NTFS drives which are accessed via SMB or CIFS sometimes show the same file-index attribute for files of different size. Well that's impossible, because the file-index attribute can only be the same for hardlinks, and hardlinks, since they are pointing to the same data, are the same files, with for sure the same size. So the SMB or CIFS implementation of such drives is broken, and this means one can not detect already existing hardlinks by reading all file-indices from all files and searching for equal indices. ln.exe has a built in sanity check on file-indices, and once it finds files with same file-index but different size, it assumes the view on this NTFS drive is broken, and invalidates all file-indices, thus assuming no hardlinks are on this drive. In such a situation --dupemerge is of great help because it scans the given path and calculates incremental MD5 hash sums for all files. This enables ln.exe to detect dupes, and hardlink equal files in the destination. On the fly Dupemerge can take a while and ln.exe prints out a warning, that it entered the On the Fly Dupemerge mode. The Dupemerge functionality can also be downloaded as a standalone tool for in-place dupemerge. See also the note on quotes. |
| --enumEnum hardlinks |
Sometimes it is convenient to find out which files are linked together, because hardlinked files might be spread around a NTFS volume. This is somehow the inverse hardlink functionality and it can be invoked as follows. ln --enum x:\path In the above example files below path are searched, and the files which are hardlinked are printed out. The --enum option first prints so called saturated and afterwards unsaturated hardlinks. For saturated hardlinks the number of files found below path matches the hardlink reference count of these files, but unsaturated hardlinks have a reference count greater than the number found below path. |
|
|
| --excludeExclude files via wildcards |
In certain situations not all files below a path should be used in Smart Copy, Smart Mirror, Delorean Copy or Clone. To accomplish this ln.exe can be run with wildcards specified to exclude certain files. ln --exclude *.ocx --exclude *.dll --delorean c:\source d:\b\dest d:\b\bk1 Basically any arbitrary wildcard expressions can be used, because the wildcard expressions are translated into a regular expression. This means that e.g *file*.ext*.* is also a valid wildcard expression for --exclude. Sometimes it is necessary to just exclude certain files along a given path: ln --exclude "*\\Res\\*\\Logfile.t*" --copy c:\source d:\b\dest The above example excludes all files Logfile.* from all directories which have \Res\ in it. This option supports taking its arguments from file. ln --exclude @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a matching pattern. e.g. *.dll*.ocxMyfile*.* |
|
|
| --excludedirExclude directories via wildcards |
In certain situations not all directories should be used in Smart Copy, Smart Mirror, Delorean Copy or Clone. To accomplish this ln.exe can be run with wildcards to exclude certain directories. ln --excludedir *test* --delorean c:\source d:\b\dest d:\b\bk1 Basically any arbitrary wildcard expressions can be used, because the wildcard expressions are translated into a regular expression. This means that e.g *file*.ext*.* is also a valid wildcard expression for --excludedir. Wildcard expression shall not span more than one directory level: e.g. *fotos\\temp* will not succeed. This option supports taking its arguments from file. ln --excludedir @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a matching pattern. e.g. *fotos*aDirDirectory with blanks |
|
|
| --excluderegexpExclude files via regular expressions |
In certain situations not all files below a path should be used in Smart Copy, Smart Mirror, Delorean Copy or Clone. To accomplish this ln.exe can be run with regular expressions specified to exclude certain files. ln --excluderegexp "[a-z]*" --copy c:\source d:\b\dest The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax. They are not casesensitiv. The regular expression specified under --excluderegexp is applied to the whole path with the filename. This option supports taking its arguments from file. ln --excluderegexp @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a regular expression. e.g. [a-z]*file[0-9]\.txt |
|
|
| --excluderegexpdirExclude directories via regular expressions |
In certain situations not all directories should be used with Smart Copy, Smart Mirror, Delorean Copy or Clone. To accomplish this ln.exe can be run with regular expressions to exclude certain directories. ln --excluderegexpdir "[a-z]*" --delorean c:\source d:\b\dest d:\b\bk1 The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax. They are not casesensitiv. The regular expression specified under --excluderegexpdir is applied to the whole path with the filename. This option supports taking its arguments from file. ln --excluderegexpdir @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a regular expression. e.g. [a-z]*directory[0-9] |
|
|
| --followfollow based on wildcards |
The delete option normally stops on reparse boundaries, but in certain cases it is useful to force the --delete option to follow pathes, which match wildcards ln --follow "Outer*" --delete "Folder 1"  This option supports taking its arguments from file. ln --follow @List.txt --delete MyPath The above example references to a file List.txt, which on every line contains a matching pattern. e.g. Outer*WhatEverSomethi?g*Directory with blanks |
|
|
| --followregexpfollow based onregular expressions |
The delete option normally stops on reparse boundaries, but in certain cases it is useful to force the --delete option to follow pathes, which match regular expressions ln --followregexpr "[a-z]*" --delete "Folder 1" The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax. They are not casesensitiv. The regular expression specified under --followregexp is applied to the whole path with the filename. This option supports taking its arguments from file. ln --followregexpr @List.txt --delete MyPath The above example references to a file List.txt, which on every line contains a regular expression. e.g. [a-z]*file[0-9]\.txt |
|
|
| --includeInclude files via wildcards |
To selectively run Smart Copy, Smart Mirror, Delorean Copy or Clone on a certain set of files, the --include option can be used with wildcards. ln --include *.ocx --include *.dll --delorean c:\source d:\b\dest d:\b\bk1 Basically any arbitrary wildcard expressions can be used, because the wildcard expressions are translated into a regular expression. This means that e.g *file*.ext*.* is also a valid wildcard expression for --include. Sometimes it is necessary to just include certain files along a given path: ln --include "*\\Res\\*\\Logfile.t*" --copy c:\source d:\b\dest The above example includes all files Logfile.* from all directories which have \Res\ in it. This option supports taking its arguments from file. ln --include @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a matching pattern. e.g. *.dll*.ocxMyfile*.* |
|
|
| --includedirInclude directories via wildcards |
To selectivley run Smart Copy, Smart Mirror, Delorean Copy or Clone on a certain set of directories, the --includedir option can be used with wildcards. ln --includedir *test --delorean c:\source d:\b\dest d:\b\bk1 Basically any arbitrary wildcard expressions can be used, because the wildcard expressions are translated into a regular expression. This means that e.g *ub?older* is also a valid wildcard expression for --includedir. Wildcard expression shall not span more than one directory level: e.g. *fotos\\temp* will not succeed This option supports taking its arguments from file. ln --includedir @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a matching pattern. e.g. *fotos*aDirDirectory with blanks |
|
|
| --includeregexpInclude filesvia regular expressions |
To selectively run Smart Copy, Smart Mirror, Delorean Copy or Clone on a certain set of files, the --includeregexp option can be used with regular expressions specified to include certain files. ln --includeregexp "[a-z]*" --copy c:\source d:\b\dest The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax. They are not casesensitiv. The regular expression specified under --includeregexp is applied to the whole path with the filename. This option supports taking its arguments from file. ln --includeregexp @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a regular expression. e.g. [a-z]*file[0-9]\.txt |
|
|
| --includeregexpdirInclude directoriesvia regular expressions |
To selectively run Smart Copy, Smart Mirror, Delorean Copy or Clone on a certain set of directories, the --includeregexpdir option can be used with regular expressions to include certain directories. ln --includeregexpdir "[a-z]*" --delorean c:\source d:\b\dest d:\b\bk1 The regular expressions used must conform to POSIX 1003.2 extended RE (ERE) syntax. They are not casesensitiv. The regular expression specified under --includeregexpdir is applied to the whole path with the filename. This option supports taking its arguments from file. ln --includeregexpdir @List.txt --copy c:\source d:\b\dest The above example references to a file List.txt, which on every line contains a regular expression. e.g. [a-z]*directory[0-9] |
|
|
| --jsonPrint outputin JSON |
To postprocess the results of ln.exe the whole output can be switched to Json. ln --json --copy x:\source d:\destination The output looks like this { "Statistics": [ { "Items": [ { "op": "#", "er": 0, "ty": "s", "pa": "D:\\path\\ln64_104.exe" } ], "Summary": { "Total": { "Folder": 1, "File": 0, "Junction": 0, "Mountpoint": 0, "ReparseUnknown": 0, "Symlink": 1, "Byte": 0 }, "Copied": { "Folder": 0, "File": 0, "Junction": "-1", "Mountpoint": "-1", "ReparseUnknown": "-1", "Symlink": "-1", "Byte": 0 }, "Linked": { "Folder": "-1", "File": 0, "Junction": 0, "Mountpoint": 0, "ReparseUnknown": 0, "Symlink": 0, "Byte": 0 }, "Skipped": { "Folder": 0, "File": 0, "Junction": 0, "Mountpoint": 0, "ReparseUnknown": 0, "Symlink": 0, "Byte": 0 }, "Excluded": { "Folder": 0, "File": 0, "Junction": 0, "Mountpoint": 0, "ReparseUnknown": 0, "Symlink": 1, "Byte": 0 }, "Failed": { "Folder": 0, "File": 0, "Junction": 0, "Mountpoint": 0, "ReparseUnknown": 0, "Symlink": 0, "Byte": 0 } }, "Times": { "Overall": 191267 } } ] } |
|
|
| --junctionCreate Junctions |
ln.exe can also create junctions, and print the target of junctions ln --junction JunctionName TargetDirectory In the above example a junction JunctionName is created, which points to TargetDirectory ln --junction JunctionName In the above example the junction JunctionName is searched for its Target and the target is printed out. rd JunctionName In the above example the junction JunctionName is removed. This is accomplished with an simple built in command prompt command. ln --junction JunctionName \\?\Volume{f6c8b244-1ce4-11e0-a607-005056c00008}\tmp In the above example the junction JunctionName is created to a volume-guid target. This is useful if you are either out of drive letters, or just want to have a link to a directory on a mounted drive regardless of which drive-letter it is mounted on. To find out the available volume-guids use the mountvol.exe command. Pushing this idea further you can now mount whole volumes onto arbitrary locations in your filesystem, even if the volume is not mounted to a drive letter at all: Format the disk in 'Disk Manager', but do not mount at all in 'Disk Manager' Use mountvol.exe to see which volumes are available. Mount the volume: ln --junction Mountpoint \\?\Volume{f6c8b244-1ce4-11e0-a607-005056c00008}\ Use 'rmdir Mountpoint' to unmount. In the early days of ln.exe the arguments of --junction were unfortunately defined in the opposite order as for --symbolic. So --junction has the target as first argument and --symbolic has it as second. So far so bad. To fix this and avoid breaking compatibility (and keep my regression test simple;-) for --junction an additional option --noitcnuj was introduced, which creates junctions and has the target as its second argument: ln --noitcnuj \\?\Volume{f6c8b244-1ce4-11e0-a607-005056c00008}\tmp JunctionName So everything which can be done with --junction can be done with --noitcnuj, but reversed argument order. Why 'noitcnuj'? Read noitcnuj backwards ... ;-) |
|
|
| --keepsymlinkrelationSave absolute/relative status |
Symbolic links can be created either absolute or relative. Setting this modifier creates symbolic links in the destination in the same way as the were in the source. ln --keepsymlinkrelation --copy x:\source x:\destination This modifier can be applied to all operation like --copy, --mirror, or --delorean. It is enabled by default if ln.exe is used with the --backup option. |
|
|
| --listList Hardlinksiblings |
With Windows7 and above finding out the siblings of a hardlink is very simple and needs no time-consuming operations ln --list filename In the above example the hardlink siblings for filename are printed out. With XP, W2K or W2K3 finding the hardlink siblings now also works, but it takes more time, because in the worst case the whole logical volume must be searched. |
|
|
| --mergeMerge |
The merge function is needed if two trees shall be merged via hardlinks into one tree. Think of the following scenario: A set of delorean backups have been created on a disk, and the disk becomes full. A new set of delorean backups from the same source is created on another disk. The two sets shall be merged into one. So copy both sets via smartcopy to one disk and use the merge functionality  The above example assumes two DeloreanSets. DeloreanSet1 contains 2 Backups and DeloreanSet2 contains 1 Backup. The DeloreanMerge operation hardlinks DeloreanSet2 into DeloreanSet1, so that DeloreanSet1 & DeloreanSet2 become one. e.g.: ln --merge x:\DeloreanSet1\bkp2 x:\DeloreanSet2\bkp3 In the above example the directory x:\DeloreanSet1\bkp2 is merged with x:\DeloreanSet2\bkp3. Merged files are marked with the ° character in the log. If the hardlink limit of 1023 was exceeded, the files are not merged, and they are prefixed in the output with °~ If the files are already hardlinked, they are prefixed in the output with °= If something goes wrong during merging the affected files it is prefixed in the output with !°f This option will not work on Network drives. See also the note on quotes. |
| --mirrorSmart Mirror |
Smart Mirror is very similar to Smart Copy and not only copies but_synchronises_ the folder Source to Destination: Smart Copy only different items from Source to Destination. Delete items no longer in Source from Destination. Smart Mirror takes care of Hardlink Relations, restores Inner Junctions or Inner Symbolic links or when issued unrolls or splices Outer Junctions or Outer Symbolic Links. The time stamps for LastWriteTime, CreationTime and LastAccessTime of files/folders/junctions/symbolic links are also restored at the corresponding destination locations during SmartMirror. Different Items means: Either the file size changed, or the LastWriteTime changed. e.g.: ln --mirror x:\source x:\destination In the above example the directory x:\source is mirrored to x:\destination, and all symbolic links and junctions within x:\destination are updated with respect to their new locations under x:\destination. The filters of --includeXXX or --excludeXXX are applied in the source and the destination location See also the note on quotes. Shell Integration Smart Mirror functionality is also available via Link Shell Extension |
| --mirror--symbolicSymbolic Clone Mirror |
The Clone Mirror function is a combination of Smart Mirror andSmartClone. Basically it creates a Symbolic Link Clone from Source to Destination directory, but also synchronises the folder Source to Destination: Create a symbolic link Clone from Source to Destination. Delete symbolic links in Destination which are no longer in Source Clone Mirror takes care of Inner Junctions, Inner Symbolic links or when issued unrolls or splices Outer Junctions or Outer Symbolic Links. Different Items means: The LastWriteTime has changed. e.g.: ln --symbolic --mirror x:\source x:\destination In the above example the directory x:\source is cloned to x:\destination, and all symbolic links and junctions within x:\destination are updated with respect to their new locations under x:\destination. Furthermore symbolic links, which are in the Destination, but have no longer a target in the Source, are deleted from the Destination. See also the note on quotes. |
| --mirror--recursiveHardlink Clone Mirror |
The Hardlink Clone Mirror function is a combination of Smart Mirror andSmartClone. Basically it creates a Hardlink Clone from Source to Destination directory, but also synchronises the folder Source to Destination: Create a Hardlink Clone from Source to Destination. Delete Hardlinks in Destination which are no longer in Source Hardlink Clone Mirror takes care of Inner Junctions, Inner Symbolic links or when issued unrolls or splices Outer Junctions or Outer Symbolic Links. Different Items means: The LastWriteTime has changed. e.g.: ln --recursive --mirror x:\source x:\destination In the above example the directory x:\source is cloned to x:\destination, and all symbolic links and junctions within x:\destination are updated with respect to their new locations under x:\destination. Furthermore files, which are in the Destination, but are no longer in the Source, are deleted from the Destination. See also the note on quotes. |
| --moveSmart Move |
Smart Move enables folders with junctions and symbolic links beneath to be renamed, and the junctions and symbolic links' targets are updated below that folder. Without Smart Move renaming of such folders would end in dangling junctions and symbolic links. With junctions or symbolic link directories it behaves as follows:  By closely looking at the above picture one can find three different types of folders/junctions: Normal Folders The folder 'Folder 3' is a normal folder. It gets moved with its content straight forward. Inner JunctionsSymlinks The folder 'Inner Junction/Symlink' is targeted at 'Inner Junction/Symlink Target'. In ln.exe terms this kind of folder is called Inner Junction/Symlink, because its target points to a folder, which is below the common anchor 'Folder 1'. Inner Junctions/Symlinks are updated properly via Smart Move in the destination location. Outer JunctionsSymlinks The folder 'Outer Junction/Symlink' is targeted at the folder 'Outer Junction/Symlink Target'. In LSE terms this kind of folder is called Outer Junction/Symlink, because its target points to a folder, which is in parallel and thus outside the anchor 'Folder 1'. Outer Junction/Symlink are not touched by Smart Move and thus stay connected to their respective target. Please note that this is different to Smart Copy, which has 3 different ways to deal with Outer Junctions/Symlinks. e.g.: ln --move x:\dir\dir2 x:\dir\newdir In the above example the directory x:\dir\dir2 is moved to x:\dir\newdir, and all symbolic links and junctions within x:\dir\dir2 are updated with respect to their new locations under x:\dir\newdir. See also the note on quotes. Shell Integration Smart Move functionality is also available via Link Shell Extension |
| --noadsSkip ADS |
The --noads option tells ln.exe not to copy Alternative Data Streams (ADS) of files and directories. This option can be useful if the destination supports NTFS, but can not deal with ADS, which happens on certain NAS drives. ln --noads --copy src dest In the above example the files are copied normally from src to dest except for ADS. |
|
|
| --noeaSkip EA Records |
The --noea option tells ln.exe not to copy EA Records of files and directories. This option can be useful if the destination supports NTFS, but can not deal with EA Records, which happens on certain NAS drives. ln --noea --copy src dest In the above example the files are copied normally from src to dest except for EA Records. |
|
|
| --outputRedirectOutput |
The output of ln.exe can be redirected to files via this commandline option ln --output filename --copy src dest In the above example all output is redirected to filename |
|
|
| --probefs |
This option of ln.exe returns the type of the filesystem. e.g NTFS, FAT, ReFs ... ln --probefs x:\ ln --probefs \\server\share\path |
|
|
| --progress |
This option is a modifier and shows the progress during operations like--mirror,--copy,--clone,--delorean ln --progress --output foo.txt --copy src dest The --progress option writes the progress only onto the console and is best used with --ouput. The --output option collects all important logging in a logfile, while the progress is written onto the console. e.g.: Enumerating ... \ Copying ... 12%, Time left: 00:00:42 The percentage progress is displayed as well as the estimated time left. |
|
|
| --quietspecifylog level |
The amount of output during various operations can be controlled via the --quiet switch: ln --quiet ... The --quiet option without arguments totally disables any output during ln.exe' operations. To specify the amount of output an optional argument can be passed to the --quiet switch: 0 Completely suppress output. This is the if same as no argument would have been passed to --quiet. 1 Only show severe errors. 2 Show the changes, e.g if a file is copied additionally during delorean copy. Furthermore show severe errors. 3 Show all output available. This is same as --quiet has been ommitted. ln --quiet 2 ... In the above example only changes are shown. |
|
|
| --recursiveSmart Clone |
ln.exe can recursively hardlink all files found below a given directory location to a newly created directory structure under a different location. In other words this means, the given directory structure is rebuilt under a different location, and all files from the given directory structure are hardlinked to the newly generated structure. Something like a xcopy, but the files are hardlinked and not copied:  e.g.: ln --recursive x:\dir\dir2 x:\dir\newdir In the above example the directories below x:\dir\dir2 are rebuilt below x:\dir\newdir, and all files from x:\dir\dir2 are hardlinked to their corresponding locations under x:\dir\newdir. A folder tree might also contain Junctions or Symbolic Links. The clone process recreates inner junction/symbolic links at the destination location very similar to the way SmartCopy does.  Outer Junctions/Symbolic links are recreated with respect to the specifiedOuter Junction/Symbolic Link handling. e.g. ln --unroll --recursive x:\dir\dir2 x:\dir\newdir In the above example the directories below x:\dir\dir2 are rebuilt below_x:\dir\newdir_, all files from x:\dir\dir2 are hardlinked to their corresponding locations under x:\dir\newdir and all junctions/symbolic links are unrolled. The cloning process is also available with Symbolic Links instead of Hardlinks.  Output See Output among Delorean Copy for a detailed description of HardlinkClone's Output Shell Integration The recursive support or HardlinkClone functionality is also available via Link Shell Extension |
|
|
| --skipfiles |
This option is a modifier to Smart Copy, Smart Mirror, Delorean Copy, or Clone, so that only directories symlinks and junctions are processed. The files are ommitted with this modifier used. ln --skipfiles --copy source destination |
|
|
| --smartrenameSmart Rename |
Smart Rename is very similar to Smart Move, but only renames junctions/symbolic links references below a given folder. ln --smartrename x:\dir\dir2 x:\dir\newdir In the above example the symbolic links/junction references below x:\dir\dir2 are renamed to x:\dir\newdir. This leaves x:\dir\dir2 with dangling symbolic links/junction, but this feature is useful if someone wants to migrate a whole disk to another physical media. ln --copy x:\ y:\unmount disk from x:\mount disk under y:\ln --smartrename y:\ x:\ unmount disk from y:\mount disk under x:\ See also the note on quotes |
| --sourceMultiple Source |
Multpiple source locations can be specified for SmartCopy, Clone and Delorean Copy. If there are junctions/symlinks between these source locations, they are handled as inner junctions/symlinks, because all source locations are dealt with as a common root.  In the above example Location 1 and Location 2 are copied to Destination.Location2/Junction_Symlink is treated as inner junctions to Location1/Folder 10 in the source, and that's why Destination/Junction_Symlink points to Destination/Folder 10 in the Destination. The objective behind this is to treat all junctions/symlinks as inner junctions/symlinks as long as they are in the set of source folders. Merging into one destination The command line invocation below copies from "c:\Location 1" and "c:\Location 2" to c:\Destination : ln --source "c:\Location2" --copy "c:\Location1" "c:\Destination" There can be more than one additional --source command-line switches: ln --source "c:\Location 2" --source "d:\Location 5" --copy "c:\Location 1" c:\Destination Specifying additional source paths can be combined with --splice or --unroll: ln --unroll --source "c:\Location 2" --copy "c:\Location 1" c:\Destination The above command copies all content from "c:\Location 2" and "c:\Location 1" to c:\Destination, but does not create a "c:\Destination\Location 2" and a "c:\Destination\Location 1". Keeping several destinations To keep several destinations the --destination option must be used: ln --unroll --source "c:\Location 2" --destination "c:\Destination\Location 2" --copy "c:\Location 1" "c:\Destination\Location 1" The --destination option must always be used with a corresponding --source option building pairs. The order of --source --destination is also important. For --copy the normal destination builds the pair: ln --source SrcA --destination DstA --source SrcB --destination DstB --source SrcC --destination DstC --copy SrcD DstD Mirror to several destinations The --mirror option can also be used to mirror to several destinations ln --source "c:\Location 2" --destination "c:\Destination\Location 2" --mirror "c:\Location 1" "c:\Destination\Location 1" Make sure that c:\Destination already exists |
| --supportfs |
There are a lot of filesystems out by third party vendors nowadays, which support hardlinks, symlinks... In order to provide the ln.exe functionality on that drives, the supported filesystems can be given: ln --supportfs winbtrfs --copy source destination Configuring your favourite filesystem to be recognized by ln.exe is on your own risk. Basically ln.exe would do all operations to the configured filesystems, which it does to NTFS. So make sure your filesystem supports the same primitives as NTFS does, otherwise certain operations will fail. |
|
|
| --symbolicSymbolic Links |
When used under Vista or Windows7/8 ln.exe can create symbolic links ln --symbolic Sourcefile.txt SymbolicLinkToSourceFile.txt In the above example a symbolic link SymbolicLinkToSourceFile.txt is created which points to sourcefile.txt. ln --symbolic Sourcefile.txt DestinationDirectory In the above example a symbolic link DestinationDirectory\Sourcefile.txt is created which points to Sourcefile.txt. ln --symbolic SourceDirectory SymbolicLinkToSourceDirectory In the above example a symbolic link SymbolicLinkToSourceDirectory is created which points to SourceDirectory. ln --symbolic SourceDirectory DestinationDirectory\ In the above example a symbolic link DestinationDirectory\SourceDirectory is created which points to SourceDirectory. A traling backslash is the trigger for this to work. ln.exe can also only show the target of a symbolic link ln --symbolic SymbolicLinkToSourceFile.txt ln.exe can also symbolically link to volume-guid targets: ln --symbolic \\?\Volume{f6c8b244-1ce4-11e0-a607-005056c00008}\tmp SymbolicLinkName In the above example the symbolic link SymbolicLinkName is created to a volume-guid target. This is useful if you are either out of drive letters, or just want to have a link to a directory on a mounted drive regardless with of which drive-letter it is mounted on. To find out the available volume-guids use the mountvol.exe command. Please note that symbolic links can only be successfully created from an administrative command prompt. ln.exe will fail on symbolic links from a normal command prompt! |
|
|
| --timetolerance |
During --mirror and --delorean it is sometimes useful to not have an exact timestamp comparison between source and destination, but kind of a fuzzy comparison, because the systemtime of NAS drives is not exactly synced with the host. To overcome this ln.exe has a --timetolerance switch to specify a value in milliseconds ln --timetolerance 2000 --mirror source destination |
|
|
| --traditionalTraditionalmode |
Some NAS boxes only support a very outdated version of the SMB protocol. SMB is used when network drives are connected. This old version of SMB in certain situations does not support the fast enumeration methods of ln.exe, which causes ln.exe to simply do nothing in SmartXXX functions. To overcome this ln.exe has a --traditional switch, which forces ln.exe to enumerate files the old, but a little slower way. ln --traditional --copy source destination ... |
|
|
| --truesizeSizecalculation |
Prints the true space used taking into account hardlinks. This means that a file with a size of e.g 12345kb and a reference count 5, will be listed with 61725kb by explorer, but indeed it only uses 12345kb, because it has a refcount of 5. ln --truesize path returns the following output Items Bytes File: 14.012 6.871.558.902 Hardlink: 5 133.991 Total: - 6.871.424.911 Folder: 2.294 - Junction: 0 - Symlink: 1 - Overall Times: 00:00:06.171 The --truesize option does not return info on alternate data streams right now. |
|
|
| --1023safeHardlink Limit Safe |
NTFS puts a 1023 limit on the number of hardlinks a file can have. In most cases this is not a problem, but if many delorean copies are stored, and files are hardlinked within a delorean copy too, it might turn out that the limit of 1023 hardlinks is reached and the error ERROR_TOO_MANY_LINKS is thrown. To overcome this either the number of stored backups can be reduced by applying theTower of Hanoi backup strategy, or by using the 1023safe option The 1023safe option can not lift NTFS limits, but for a little performance penalty it can check if the limit is exceeded and if neccessary introduce a copy in the chain of hardlinks, and then hardlink the files to this newly introduced copy:  In the above example a setup is shown, which has already applied three iterations of delorean copy: Intitially there was a directory which contained the file B, and the hardlinks A001 to A500. So the reference count was 1 for file B, and 500 for A001 to A500. So far so good. The first Delorean Copy copied over from Backup0 to Backup1, which increased the reference count for file B to 2, and A001 to A500 were pushed to a reference count of 1000. Still ok. With the third Delorean Copy the reference count for file B goes to 3 and for A001 to A500 it would have been increased to 1500. This would be a violation of the 1023 limit! Without the --1023safe option, this delorean copy would fail. With the --1023safe option ln.exe checks if the limit would have been reached, and if neccessary introduces a copy of A001 in Backup2 instead of hardlinks for A001, and links A002 to A500 to the newly created copy. This reduces the refcount for A001 ... A500 again to 500, and the game can go on. So why not using the 1023safe option by default: There is a little performance penalty, because for the enumeration on the items to be cloned from one backup to the other, ln.exe has to switch back the to the traditional mode, which is slightly slower. |