Looking for:
Download diffstat.exe |
- Linux Kernel Download | TechSpot
There is a special case that, the operating system is a bit system, but you are not sure whether the program is bit or bit. If you encounter this situation, check the file path to see whether there are any other files located in. If yes, please check the properties of these files, and you will know if the file you need is bit or bit.
If you still can't find the file you need, you can leave a "message" on the webpage. If you also need to download other files, you can enter the file name in the input box. File Finder:. If you have any further questions or need help, please leave us a message:. Leave a Reply Your email address will not be published. Linux Project. User rating:. Open-source antivirus ClamAV finally goes 1. Windows Subsystem for Linux comes to the Microsoft Store for everyone. Linux kernel 5.
Dual Booting: Windows and Ubuntu. Software similar to Linux Kernel 6. Debian Debian is a free operating system OS for your computer. This version is known as "Bullseye". Linux Mint The purpose of Linux Mint is to produce a modern, elegant and comfortable operating system which is both powerful and easy to use. Arch Linux If you do not need to target Windows specifically, but you are just looking to learn and play with the GNU toolchain and you have a windows machine, I recommend installing Ubuntu or Suse on Windows through the Microsoft Store.
This will provide a Linux environment in Windows for you to work with. Download the. After installing, navigate to the directory where it was installed, and run msys2. After opening it you should find yourself in a bash shell.
After your initial install it is a good idea to update all the packages. Update everything using:. In the MSYS2 bash shell, use pacman again to install the build toolchain and compilers.
Note that vim and cmake are optional, but handy to have. Sometimes what you want instead is a set of patches; for this you can use git-format-patch[1] :.
You can always view an old version of a file by just checking out the correct revision first. But sometimes it is more convenient to be able to view an old version of a single file without checking anything out; this command does that:. Before the colon may be anything that names a commit, and after it may be any path to a file tracked by Git.
You could compare the object names:. Or you could recall that the Suppose you know that the commit e05db0fd fixed a certain problem. The git-describe[1] command does the opposite, naming the revision using a tag on which the given commit is based:.
If you just want to verify whether a given tagged version contains a given commit, you could use git-merge-base[1] :. The merge-base command finds a common ancestor of the given commits, and always returns one or the other in the case where one is a descendant of the other; so the above output shows that e05db0fd actually is an ancestor of v1. As yet another alternative, the git-show-branch[1] command lists the commits reachable from its arguments with a display on the left-hand side that indicates which arguments that commit is reachable from.
So, if you run something like. Suppose you would like to see all the commits reachable from the branch head named master but not from any other head in your repository. We can list all the heads in this repository with git-show-ref[1] :. We can get just the branch-head names, and remove master , with the help of the standard utilities cut and grep:. Obviously, endless variations are possible; for example, to see all commits reachable from some head but not from any tag in the repository:.
See gitrevisions[7] for explanations of commit-selecting syntax such as --not. The git-archive[1] command can create a tar or zip archive from any version of a project; for example:. The output file format is inferred from the output file extension if possible, see git-archive[1] for details. Versions of Git older than 1. Somebody hands you a copy of a file, and asks which commits modified a file such that it contained the given content either before or after the commit.
You can find out with this:. Figuring out why this works is left as an exercise to the advanced student. The git-log[1] , git-diff-tree[1] , and git-hash-object[1] man pages may prove helpful. Before creating any commits, you should introduce yourself to Git. The easiest way to do so is to use git-config[1] :.
The file is plain text, so you can also edit it with your favorite editor. At the beginning, the content of the index will be identical to that of the HEAD. The command git diff --cached , which shows the difference between the HEAD and the index, should therefore produce no output at that point. Note that git add always adds just the current contents of a file to the index; further changes to the same file will be ignored unless you run git add on the file again.
Check to make sure it looks like what you expected with. You can also use git-gui[1] to create commits, view changes in the index and the working tree files, and individually select diff hunks for inclusion in the index by right-clicking on the diff hunk and choosing "Stage Hunk For Commit".
The text up to the first blank line in a commit message is treated as the commit title, and that title is used throughout Git. For example, git-format-patch[1] turns a commit into email, and it uses the title on the Subject line and the rest of the commit in the body. A project will often generate files that you do not want to track with Git. This typically includes files generated by a build process or temporary backup files made by your editor. Of course, not tracking files with Git is just a matter of not calling git add on them.
But it quickly becomes annoying to have these untracked files lying around; e. You can tell Git to ignore certain files by creating a file called. See gitignore[5] for a detailed explanation of the syntax.
You can also place. If you wish the exclude patterns to affect only certain repositories instead of every repository for a given project , you may instead put them in a file in your repository named. Some Git commands can also take exclude patterns directly on the command line. See gitignore[5] for the details. You can rejoin two diverging branches of development using git-merge[1] :.
A merge is made by combining the changes made in branchname and the changes made up to the latest commit in your current branch since their histories forked. The work tree is overwritten by the result of the merge when this combining is done cleanly, or overwritten by a half-merged results when this combining results in conflicts. Therefore, if you have uncommitted changes touching the same files as the ones impacted by the merge, Git will refuse to proceed.
If the changes are independent enough, Git will automatically complete the merge and commit the result or reuse an existing commit in case of fast-forward , see below. Conflict markers are left in the problematic files, and after you resolve the conflicts manually, you can update the index with the contents and run Git commit, as you normally would when creating a new file.
If you examine the resulting commit using gitk, you will see that it has two parents, one pointing to the top of the current branch, and one to the top of the other branch.
Files with conflicts are marked specially in the index, so until you resolve the problem and update the index, git-commit[1] will fail:. Also, git-status[1] will list those files as "unmerged", and the files with conflicts will have conflict markers added, like this:. Note that the commit message will already be filled in for you with some information about the merge. Normally you can just use this default message unchanged, but you may add additional commentary of your own if desired.
The above is all you need to know to resolve a simple merge. But Git also provides more information to help resolve conflicts:. All of the changes that Git was able to merge automatically are already added to the index file, so git-diff[1] shows only the conflicts.
It uses an unusual syntax:. During the merge, the index holds three versions of each file. Each of these three "file stages" represents a different version of the file:.
Same for stage 3. The diff above shows the differences between the working-tree version of file. After resolving the conflict in the obvious way but before updating the index , the diff will look like:. This shows that our resolved version deleted "Hello world" from the first parent, deleted "Goodbye" from the second parent, and added "Goodbye world", which was previously absent from both.
The git-log[1] and gitk[1] commands also provide special help for merges:. You may also use git-mergetool[1] , which lets you merge the unmerged files using external tools such as Emacs or kdiff3. If you get stuck and decide to just give up and throw the whole mess away, you can always return to the pre-merge state with.
There is one special case not mentioned above, which is treated differently. Normally, a merge results in a merge commit, with two parents, one pointing at each of the two lines of development that were merged. You can create a new commit that undoes whatever was done by the old commit. This is the correct thing if your mistake has already been made public. You can go back and modify the old commit.
You should never do this if you have already made the history public; Git does not normally expect the "history" of a project to change, and cannot correctly perform repeated merges from a branch that has had its history changed. Creating a new commit that reverts an earlier change is very easy; just pass the git-revert[1] command a reference to the bad commit; for example, to revert the most recent commit:.
This will create a new commit which undoes the change in HEAD. You will be given a chance to edit the commit message for the new commit. In this case Git will attempt to undo the old change while leaving intact any changes made since then. If more recent changes overlap with the changes to be reverted, then you will be asked to fix conflicts manually, just as in the case of resolving a merge. If the problematic commit is the most recent commit, and you have not yet made that commit public, then you may just destroy it using git reset.
Alternatively, you can edit the working directory and update the index to fix your mistake, just as if you were going to create a new commit , then run. Again, you should never do this to a commit that may already have been merged into another branch; use git-revert[1] instead in that case.
It is also possible to replace commits further back in the history, but this is an advanced topic to be left for another chapter. In the process of undoing a previous bad change, you may find it useful to check out an older version of a particular file using git-restore[1]. The command. It does not change branches.
If you just want to look at an old version of the file, without modifying the working directory, you can do that with git-show[1] :. While you are in the middle of working on something complicated, you find an unrelated but obvious and trivial bug. You would like to fix it before continuing. You can use git-stash[1] to save the current state of your work, and after fixing the bug or, optionally after doing so on a different branch and then coming back , unstash the work-in-progress changes.
This command will save your changes away to the stash , and reset your working tree and the index to match the tip of your current branch. Then you can make your fix as usual. On large repositories, Git depends on compression to keep the history information from taking up too much space on disk or in memory. However, compressing a large repository may take a while, so you may want to call gc explicitly to avoid automatic compression kicking in when it is not convenient.
The git-fsck[1] command runs a number of self-consistency checks on the repository, and reports on any problems. This may take some time. You will see informational messages on dangling objects. They are objects that still exist in the repository but are no longer referenced by any of your branches, and can and will be removed after a while with gc. You can run git fsck --no-dangling to suppress these messages, and still view real errors. Say you modify a branch with git reset --hard , and then realize that the branch was the only reference you had to that point in history.
Fortunately, Git also keeps a log, called a "reflog", of all the previous values of each branch. So in this case you can still find the old history using, for example,. This lists the commits reachable from the previous version of the master branch head.
This syntax can be used with any Git command that accepts a commit, not just with git log. Some other examples:. The reflogs are kept by default for 30 days, after which they may be pruned. Note that the reflog history is very different from normal Git history. While normal history is shared by every repository that works on the same project, the reflog history is not shared: it tells you only about how the branches in your local repository have changed over time. In some situations the reflog may not be able to save you.
For example, suppose you delete a branch, then realize you need the history it contained. The reflog is also deleted; however, if you have not yet pruned the repository, then you may still be able to find the lost commits in the dangling objects that git fsck reports. See Dangling objects for the details. Thus you get exactly the history reachable from that commit that is lost. And notice that it might not be just one commit: we only report the "tip of the line" as being dangling, but there might be a whole deep and complex commit history that was dropped.
If you decide you want the history back, you can always create a new reference pointing to it, for example, a new branch:.
Other types of dangling objects blobs and trees are also possible, and dangling objects can arise in other situations. After you clone a repository and commit a few changes of your own, you may wish to check the original repository for updates and merge them into your own work.
We have already seen how to keep remote-tracking branches up to date with git-fetch[1] , and how to merge two branches. However, the git-pull[1] command provides a way to do this in one step:. In fact, if you have master checked out, then this branch has been configured by git clone to get changes from the HEAD branch of the origin repository.
So often you can accomplish the above with just a simple. More generally, a branch that is created from a remote-tracking branch will pull by default from that branch. See the descriptions of the branch.
In addition to saving you keystrokes, git pull also helps you by producing a default commit message documenting the branch and repository that you pulled from. But note that no such commit will be created in the case of a fast-forward ; instead, your branch will just be updated to point to the latest commit from the upstream branch. The git pull command can also be given. If you just have a few changes, the simplest way to submit them may just be to send them as patches in email:.
You can insert commentary on individual patches after the three dash line which format-patch places after the commit message but before the patch itself. You can then import these into your mail client and send them by hand. However, if you have a lot to send at once, you may prefer to use the git-send-email[1] script to automate the process. Consult the mailing list for your project first to determine their requirements for submitting patches.
Git also provides a tool called git-am[1] am stands for "apply mailbox" , for importing such an emailed series of patches. Just save all of the patch-containing messages, in order, into a single mailbox file, say patches.
Git will apply each patch in order; if any conflicts are found, it will stop, and you can fix the conflicts as described in " Resolving a merge ". The -3 option tells Git to perform a merge; if you would prefer it just to abort and leave your tree and index untouched, you may omit that option. Once the index is updated with the results of the conflict resolution, instead of creating a new commit, just run.
The final result will be a series of commits, one for each patch in the original mailbox, with authorship and commit log message each taken from the message containing each patch. Another way to submit changes to a project is to tell the maintainer of that project to pull the changes from your repository using git-pull[1].
In the section " Getting updates with git pull " we described this as a way to get updates from the "main" repository, but it works just as well in the other direction. For projects with few developers, or for synchronizing a few private repositories, this may be all you need. However, the more common way to do this is to maintain a separate public repository usually on a different host for others to pull changes from.
This is usually more convenient, and allows you to cleanly separate private work in progress from publicly visible work. You will continue to do your day-to-day work in your personal repository, but periodically "push" changes from your personal repository into your public repository, allowing other developers to pull from that repository. So the flow of changes, in a situation where there is one other developer with a public repository, looks like this:.
We first create a new clone of the repository and tell git daemon that it is meant to be public:. The resulting directory proj. Next, copy proj. You can use scp, rsync, or whatever is most convenient. You can then skip to the section " Pushing changes to a public repository ", below. Otherwise, all you need to do is start git-daemon[1] ; it will listen on port By default, it will allow access to any directory that looks like a Git directory and contains the magic file git-daemon-export-ok.
Passing some directory paths as git daemon arguments will further restrict the exports to those paths. You can also run git daemon as an inetd service; see the git-daemon[1] man page for details. See especially the examples section. The Git protocol gives better performance and reliability, but on a host with a web server set up, HTTP exports may be simpler to set up. All you need to do is place the newly created bare Git repository in a directory that is exported by the web server, and make some adjustments to give web clients some extra information they need:.
For an explanation of the last two lines, see git-update-server-info[1] and githooks[5]. Advertise the URL of proj. Anybody else should then be able to clone or pull from that URL, for example with a command line like:.
Note that the two techniques outlined above exporting via http or git allow other maintainers to fetch your latest changes, but they do not allow write access, which you will need to update the public repository with the latest changes created in your private repository. The simplest way to do this is using git-push[1] and ssh; to update the remote branch named master with the latest state of your branch named master , run.
As with git fetch , git push will complain if this does not result in a fast-forward ; see the following section for details on handling this case. Note that the target of a push is normally a bare repository.
You can also push to a repository that has a checked-out working tree, but a push to update the currently checked-out branch is denied by default to prevent confusion. See the description of the receive. As with git fetch , you may also set up configuration options to save typing; so, for example:. See the explanations of the remote. If a push would not result in a fast-forward of the remote branch, then it will fail with an error like:.
You may force git push to perform the update anyway by preceding the branch name with a plus sign:. Alternatively, you can use the -f flag to force the remote update, as in:. Normally whenever a branch head in a public repository is modified, it is modified to point to a descendant of the commit that it pointed to before.
By forcing a push in this situation, you break that convention. See Problems with rewriting history. Nevertheless, this is a common practice for people that need a simple way to publish a work-in-progress patch series, and it is an acceptable compromise as long as you warn other developers that this is how you intend to manage the branch. In that case, the correct solution is to retry the push after first updating your work: either by a pull, or by a fetch followed by a rebase; see the next section and gitcvs-migration[7] for more.
Another way to collaborate is by using a model similar to that commonly used in CVS, where several developers with special rights all push to and pull from a single shared repository.
See gitcvs-migration[7] for instructions on how to set this up. And when that becomes too much, git pull provides an easy way for that maintainer to delegate this job to other maintainers while still allowing optional review of incoming changes. The lack of a central group of "committers" means there is less need for formal decisions about who is "in" and who is "out". The git-instaweb[1] command provides a simple way to start browsing the repository using gitweb.
The default server when using instaweb is lighttpd. A shallow clone , with its truncated history, is useful when one is interested only in recent history of a project and getting full history from the upstream is expensive.
A shallow clone is created by specifying the git-clone[1] --depth switch. The depth can later be changed with the git-fetch[1] --depth switch, or full history restored with --unshallow. Merging inside a shallow clone will work as long as a merge base is in the recent history. Otherwise, it will be like merging unrelated histories and may have to result in huge conflicts. This limitation may make such a repository unsuitable to be used in merge based workflows.
A "test" tree into which patches are initially placed so that they can get some exposure when integrated with other ongoing development. This tree is available to Andrew for pulling into -mm whenever he wants. A "release" tree into which tested patches are moved for final sanity checking, and as a vehicle to send them upstream to Linus by sending him a "please pull" request.
He also uses a set of temporary branches "topic branches" , each containing a logical grouping of patches. Important note! If you have any local changes in these branches, then this merge will create a commit object in the history with no local changes Git will simply do a "fast-forward" merge. Many people dislike the "noise" that this creates in the Linux history, so you should avoid doing this capriciously in the release branch, as these noisy commits will become part of the permanent history when you ask Linus to pull from the release branch.
A few configuration variables see git-config[1] can make it easy to push both branches to your public tree. See Setting up a public repository. Then you can push both the test and release trees using git-push[1] :. Now to apply some patches from the community. Picking a stable base for your branch will: 1 help you: by avoiding inclusion of unrelated and perhaps lightly tested changes 2 help future bug hunters that use git bisect to find problems.
Now you apply the patch es , run some tests, and commit the change s. If the patch is a multi-part series, then you should apply each as a separate commit to this branch.
When you are happy with the state of this change, you can merge it into the "test" branch in preparation to make it public:. Sometime later when enough time has passed and testing done, you can pull the same branch into the release tree ready to go upstream.
This is where you see the value of keeping each patch or patch series in its own branch. It means that the patches can be moved into the release tree in any order. After a while, you will have a number of branches, and despite the well chosen names you picked for each of them, you may forget what they are for, or what status they are in. To get a reminder of what changes are in a specific branch, use:. If this branch has not yet been merged, you will see some log entries. If it has been merged, then there will be no output.
You detect this when the output from:. Some changes are so trivial that it is not necessary to create a separate branch and then merge into each of the test and release branches.
For these changes, just apply directly to the release branch, and then merge that into the test branch. After pushing your work to mytree , you can use git-request-pull[1] to prepare a "please pull" request message to send to Linus:. Normally commits are only added to a project, never taken away or replaced.
Suppose you are a contributor to a large project, and you want to add a complicated feature, and to present it to the other developers in a way that makes it easy for them to read your changes, verify that they are correct, and understand why you made each change.
If you present all of your changes as a single patch or commit , they may find that it is too much to digest all at once. If you present them with the entire history of your work, complete with mistakes, corrections, and dead ends, they may be overwhelmed.
The complete series produces the same end result as your own probably much messier! We will introduce some tools that can help you do this, explain how to use them, and then explain some of the problems that can arise because you are rewriting history.
Suppose that you create a branch mywork on a remote-tracking branch origin , and create some commits on top of it:. You have performed no merges into mywork, so it is just a simple linear sequence of patches on top of origin :.
Some more interesting work has been done in the upstream project, and origin has advanced:. At this point, you could use pull to merge your changes back in; the result would create a new merge commit, like this:. However, if you prefer to keep the history in mywork a simple series of commits without any merges, you may instead choose to use git-rebase[1] :.
This will remove each of your commits from mywork, temporarily saving them as patches in a directory named. The result will look like:.
In the process, it may discover conflicts. In that case it will stop and allow you to fix the conflicts; after fixing conflicts, use git add to update the index with those contents, and then, instead of running git commit , just run.
No comments:
Post a Comment