Initially, Linux was primarily developed and used by individual enthusiasts on personal computers. Since then, Linux has gained the support of major corporations such as IBM, Sun Microsystems, Hewlett-Packard, and Novell, Inc. for use in servers and is gaining popularity in the personal computer market.[1] It is used in systems ranging from supercomputers to mobile phones. Proponents and analysts attribute its success to its security, reliability,[2] low cost, and freedom from vendor lock-in.[3]
[edit]History
Image:Linus Torvalds.jpeg
Linus Torvalds, creator of the Linux kernel.In 1983, Richard Stallman founded the GNU Project, with the goal of developing a complete Unix-like operating system composed entirely of free software. By the beginning of the 1990s, GNU had produced or collected most of the necessary components of this system — libraries, compilers, text editors, a Unix shell — except for the core component, the kernel. The GNU project began developing a kernel, the GNU Hurd, in 1990, based on the Mach microkernel, but the development of this Mach-based design proved difficult and proceeded slowly.
Meanwhile, in 1991, another kernel was begun as a hobby by Finnish university student Linus Torvalds while attending the University of Helsinki.[4] Torvalds originally used Minix on his own computer, a simplified Unix-like system written by Andrew Tanenbaum for teaching operating system design. However, Tanenbaum did not permit others to extend his operating system, leading Torvalds to create a replacement for Minix.
Originally, Torvalds called his kernel "Freax" for "free" and "freak" and with the often-used X in the names of Unix-like systems. The name "Linux" was coined by Ari Lemmke, who administered an FTP server belonging to the Finnish University Networkhe invented the name Linux for the directory from which Torvalds' project was first available for download.[5]
Image:Unix.png
A graphic history of Unix systems. Linux is a Unix-type system but its source code does not descend from the original Unix.At first a computer running Minix was necessary in order to configure and install Linux. Initial versions of Linux also required another operating system to be present in order to boot from a hard disk, but soon there were independent boot loaders such as LILO. The Linux system quickly surpassed Minix in functionalityTorvalds and other early Linux kernel developers adapted their work for the GNU components and user-space programs to create a complete, fully functional, and free operating system.
Today, Torvalds continues to direct the development of the kernel, while other subsystems such as the GNU components continue to be developed separately (Linux kernel development is not part of the GNU Project). Other groups and companies combine and distribute these components with additional application software in the form of Linux distributions.
[edit]Portability
See also: Linux (kernel)
The Linux kernel was originally designed only for Intel 80386 microprocessors, but now supports a wide variety of computer architectures. Linux is one of the most widely ported operating systems, running on a diverse range of systems from the hand-held ARM-based iPAQ to the mainframe IBM System z9. Specialised distributions exist for less mainstream architectures.
[edit]Copyright, licensing, and the Linux trademark
The Linux kernel and most GNU software are licensed under the GNU General Public License. The GPL requires that all distributed source code modifications and derived works also be licensed under the GPL, and is sometimes referred to as a "share and share-alike" or "copyleft" license. In 1997, Linus Torvalds stated, "Making Linux GPL'd was definitely the best thing I ever did."[6] Other software may use other licensesmany libraries use the GNU Lesser General Public License (LGPL), a more permissive variant of the GPL, and the X Window System uses the MIT License.
In the United States, the name Linux is a trademark[7] registered to Linus Torvalds. Initially, nobody registered it, but on August 15, 1994, William R. Della Croce, Jr. filed for the trademark Linux, and then demanded royalties from Linux distributors. In 1996, Torvalds and some affected organizations sued to have the trademark assigned to Torvalds, and in 1997 the case was settled[8] . The licensing of the trademark is now handled by the Linux Mark Institute. Torvalds has stated that he only trademarked the name to prevent someone else from using it, but was bound in 2005 by United States trademark law to take active measures to enforce the trademark. As a result, the LMI sent out a number of letters to distribution vendors requesting that a fee be paid for the use of the name, and a number of companies have complied.[9]
[edit]Pronunciation
In 1992, Torvalds explained how he pronounces the word Linux:
“ 'li' is pronounced with a short [ee] sound: compare prInt, mInImal etc. 'nux' is also short, non-diphthong, like in pUt {IPA /ʊ/}. It's partly due to minix: linux was just my working name for the thing, and as I wrote it to replace minix on my system, the result is what it is... linus' minix became linux. „
— Linus Torvalds , comp.os.linux newsgroup[5]
An audio file of Torvalds saying "Hello, this is Linus Torvalds, and I pronounce Linux as Linux" can be found here. Note that in English, "Linux" and "Minix" are usually pronounced with a short i (IPA: /ɪ/) sound that is different from Torvalds' Finland-Swedish pronunciation of these words.
[edit]Linux and the GNU Project
Image:Richard Matthew Stallman.jpeg
Richard Stallman, founder of the GNU project for a free operating system.Main article: GNU/Linux naming controversy
The goal of the GNU project is to produce a Unix-compatible operating system consisting entirely of free software, and most general-purpose Linux distributions rely on GNU libraries and tools written to that effect. The Free Software Foundation views these Linux distributions as "variants" of the GNU system, and asks that such operating systems be referred to as GNU/Linux or a Linux-based GNU system. While some distributions make a point of using the combined form - notably Debian GNU/Linux - its use outside of the enthusiast community is limited, and Linus Torvalds has said that he finds calling Linux in general GNU/Linux "just ridiculous" [10] . The distinction between the Linux kernel and distributions based on it is a source of confusion to many newcomers, and the naming remains controversial.
[edit]SCO litigation
Main article: SCO-Linux controversies
In March 2003, the SCO Group filed a lawsuit against IBM, claiming that IBM had contributed portions of SCO's copyrighted code to the Linux kernel in violation of IBM's license to use Unix. Additionally, SCO sent letters to a number of companies warning that their use of Linux without a license from SCO may be actionable, and claimed in the press that they would be suing individual Linux users. This controversy has involved lawsuits by SCO against DaimlerChrysler (dismissed in 2004), and AutoZone, and by Red Hat and others against SCO. Furthermore, whether SCO even owns the relevant Unix copyrights is currently disputed by Novell.
As per the Utah District Court ruling on July 3, 2006182 claims out of 294 claims made by SCO against IBM have been dismissed.[11]
SCO's claims have varied widely. As of 2006, no proof of SCO's claims of copied code in Linux has been provided.
[edit]Development efforts
More Than a Gigabuck: Estimating GNU/Linux's Size, a 2001 study of Red Hat Linux 7.1, found that this distribution contained 30 million source lines of code.[12] Using the Constructive Cost Model, the study estimated that this distribution required about eight thousand man-years of development time. According to the study, if all this software had been developed by conventional proprietary means, it would have cost about 1.08 billion dollars (year 2000 U.S. dollars) to develop in the United States.
The majority of the code (71%) was written in the C programming language, but many other languages were used, including C++, Lisp, assembly language, Perl, Fortran, Python and various shell scripting languages. Slightly over half of all lines of code were licensed under the GPL. The Linux kernel was 2.4 million lines of code, or 8% of the total.
In a later study, Counting potatoes: The size of Debian 2.2, the same analysis was performed for Debian GNU/Linux version 2.2.[13] This distribution contained over fifty-five million source lines of code, and the study estimated that it would have cost 1.9 billion dollars (year 2000 U.S. dollars) to develop by conventional means.
[edit]Applications
Image:Linux-SuSE-KDE.png
A KDE desktop on the SUSE distribution.Linux has historically been used mainly as a server operating system, but its low cost, flexibility, and Unix background make it suitable for a wide range of applications. Linux is the cornerstone of the "LAMP" server-software combination (Linux, Apache, MySQL, Perl/PHP/Python) which has achieved popularity among developers, and which is one of the more common platforms for website hosting.
Due to its low cost and its high configurability, Linux is often used in embedded systems such as television set-top boxes, mobile phones, and handheld devices. Linux has become a major competitor to the proprietary Symbian OS found in many mobile phones, and it is an alternative to the dominant Windows CE and Palm OS operating systems on handheld devices. The popular TiVo digital video recorder uses a customized version of Linux. Several network firewall and router standalone products, including several from Linksys, use Linux internally, using its advanced firewalling and routing capabilities.
Linux is increasingly common as an operating system for supercomputers. In the November 2005 TOP500 list of supercomputers, the two fastest supercomputers in the world ran Linux. Of the 500 systems, 371 (74.2%) ran some version of Linux, including seven of the top ten.
The Sony PlayStation 3 video game console, scheduled to be released in November 2006, will run Linux by default. Sony has previously released a PS2 Linux do-it-yourself kit for their PlayStation 2 video game console. Game developers like Atari and id Software have released titles to the Linux desktop. Linux Game Publishing also produces games for Linux, licensing and porting them from their Windows source code.
The One Laptop Per Child project, which aims to provide computing devices to all children in developing nations, uses Linux as the devices' operating system.
[edit]Distributions
For more details on this topic, see Linux distribution.
Linux is predominantly used as part of a Linux distribution (commonly called a "distro"). These are compiled by individuals, loose-knit teams, and commercial and volunteer organizations. They commonly include additional system and application software, an installer system to ease initial system setup, and integrated management of software installation and upgrading. Distributions are created for many different purposes, including computer architecture support, localization to a specific region or language, real-time applications, and embedded systems, and many deliberately include only free software. Currently, over three hundred distributions are actively developed, with about a dozen distributions being most popular for general-purpose use.[14]
A typical general-purpose distribution includes the Linux kernel, some GNU libraries and tools, command-line shells, the graphical X Window System and an accompanying desktop environment such as KDE or GNOME, together with thousands of application software packages, from office suites to compilers, text editors, and scientific tools.
[edit]Desktop usage
Image:Gnome-2.14.png
A GNOME desktop running from the GNOME LiveCD.See also: Comparison of Windows and Linux
The high level of access granted to Linux's internals has led to Linux users traditionally tending to be more technologically oriented than users of Microsoft Windows and Mac OS, sometimes revelling in the tag of "hacker" or "geek". Linux and other free software projects have been frequently criticized for not going far enough to ensure ease of use.[citation needed]
This stereotype has begun to be dispelled in recent years. Linux may now be used with a user interface that is very similar to those running on other operating systems. Users may have to switch application software, and there are often fewer "known" options (as in the case of computer games) but there exist replacements for all general-purpose software, and general applications like spreadsheets, word processors, and browsers are available for Linux in profusion. Additionally, a growing number of proprietary software vendors are supporting Linux,[15] and compatibility layers such as the Wine system allow some Windows application software and drivers to be used on Linux without requiring the vendor to adapt them.
Linux's roots in the Unix operating system mean that while graphical configuration tools and control panels are available for many system settings and services, plain-text configuration files are still commonly used to configure the OS and may be exposed to users. In general, the command shell does not protect against accidents like file deletion, and the user interfaces of older programs are sometimes inconsistent.
The Berlin-based organization Relevantive concluded in 2003 that the usability of Linux for a set of desktop-related tasks was "nearly equal to Windows XP."[16] Since then, there have been numerous independent studies and articles which indicate that a modern Linux desktop using either GNOME or KDE is on par with Microsoft Windows in a business setting.[17]
[edit]Market share and uptake
Further information: Linux adoption
According to the market research company IDC, 25% of servers and 2.8% of desktop computers ran Linux as of 2004.[18]
The Linux market is rapidly growing and the revenue of servers, desktops, and packaged software running Linux is expected to exceed $35.7 billion by 2008.[19] The actual installed user base may be higher than indicated by this figure, as most Linux distributions and applications are freely available and redistributable.
The paper Why Open Source Software / Free Software (OSS/FS)? Look at the Numbers![20] identifies many quantitative studies of open source software, on topics including market share and reliability, with many studies specifically examining Linux.
[edit]Installation
The most common method of installing Linux on a personal computer is by booting from a CD-ROM that contains the installation program and installable software. Such a CD can be burned from a downloaded ISO image, purchased alone for a low price, can be obtained as part of a box set that may also include manuals and additional commercial software and in a few cases shipped for free by request. Mini CD images allow Linux to be installed from a disk with a small form factor.
As with servers, personal computers that come with Linux already installed are available from vendors including Hewlett-Packard and Dell, although generally only for their business desktop line.
Alternatives to traditional desktop installation include thin client installation, where the operating system is loaded and run from a centralised machine over a network connectionand running from a Live CD, where the computer boots the entire operating system from CD without first installing it on the computer's hard disk.
On embedded devices, Linux is typically held in the device's firmware and may or may not be consumer-accessible.
[edit]Programming on Linux
GNU Compiler Collection (GCC) is the de facto standard compiler for Linux. GCC provides frontends for C, [[C++]], Java and others. Most distributions also come installed with Perl, Python and other language interpreters, and several now include C# via the Mono project.
There are a number of Integrated development environments available including KDevelop, Anjuta, NetBeans, and Eclipse while the traditional editors Emacs and Vim remain popular.[citation needed]
The two main widget toolkits used for contemporary GUI programming are Qt and the Gimp Toolkit, known as [[GTK+]].
As well as these free and open source options, there are proprietary compilers and tools available from a range of companies such as Intel,[21] PathScale[22] and the Portland Group.[23]
[edit]Support
Technical support is provided by commercial suppliers and by other Linux users, usually in online forums, IRC, newsgroups, and mailing lists. Linux User Groups have traditionally been organized to provide support for Linux in specific cities and regions.
The business model of commercial suppliers is generally dependent on charging for support, especially for business users. A number of companies offer a specialized business version of their distribution, which adds proprietary support packages and tools to administer higher numbers of installations or to simplify administrative tasks.
Conflict-Based Checking the Integrity of Linux Package Dependencies作者：
Yuqing LAN ；Mingxia KUANG ；Wenbin ZHOU
期刊：
IEICE transactions on information and systems EISCI
年，卷(期)：
2011, E94-D(12)
A Linux operating system release is composed of a large number of software packages, with complex dependencies. The management of dependency relationship is the foundation of building and maintaining a Linux operating system release, and checking the integrity of the dependencies is the key of the dependency management. The widespread adoption of Linux operating systems in many areas of the information technology society has drawn the attention on the issues regarding how to check the integrity of complexity dependencies of Linux packages and how to manage a huge number of packages in a consistent and effective way. Linux distributions have already provided the tools for managing the tasks of installing, removing and upgrading the packages they were made of. A number of tools have been provided to handle these tasks on the client side. However, there is a lack of tools that could help the distribution editors to maintain the integrity of Linux package dependencies on the server side. In this paper we present a method based on conflict to check the integrity of Linux package dependencies. From the perspective of conflict, this method achieves the goal to check the integrity of package dependencies on the server side by removing the conflict associating with the packages. Our contribution provides an effective and automatic way to support distribution editors in handling those issues. Experiments using this method are very successful in checking the integrity of package dependencies in Linux software distributions.
Anatomy of Linux flash file systemsOptions and architectures
Summary: You've probably heard of Journaling Flash File System (JFFS) and Yet
Another Flash File System (YAFFS), but do you know what it means to have a file
system that assumes an underlying flash device? This article introduces you to
flash file systems for Linux®, explores how they care for their underlying
consumable devices (flash parts) through wear leveling, and identifies the
various flash file systems available along with their fundamental designs.
Solid-state drives are all the rage these days, but embedded systems have
used solid-state devices for storage for quite some time. You'll find flash
file systems used in personal digital assistants (PDAs), cell phones, MP3
players, digital cameras, USB flash drives (UFDs), and even laptop computers.
In many cases, the file systems for commercial devices can be custom and
proprietary, but they face the same challenges discussed below.
Flash-based file systems come in a variety of forms. This article explores
a couple of the read-only file systems and also reviews the various read/write
file systems available today and how they work. But first, let's explore the
flash devices and the challenges that they introduce.
Flash memory technologies
Flash memory, which can come in several different technologies, is non-volatile
memory, which means that its contents persist after its source of power is
removed. For a great history of flash memory devices, see Resources.
Two of the most common types of flash devices are defined by their
respective technologies: NOR and NAND. NOR-based flash is the older technology
that supported high read performance at the expense of smaller capacities. NAND
flash offers higher capacities with significantly faster write and erase
performance. NAND also requires a much more complicated input/output (I/O)
interface.
Flash parts are commonly divided into partitions, which allows
multiple operations to occur simultaneously (erasing one partition while
reading from another). Partitions are further divided into blocks
(commonly 64KB or 128KB in size). Firmware that uses the partitions can further
apply unique segmenting to the blocks—for example, 512-byte segments within a
block, not including metadata.
Flash devices exhibit a common constraint that requires device management
when compared to other storage devices such as RAM disks. The only Write
operation permitted on a flash memory device is to change a bit from a one to a
zero. If the reverse operation is needed, then the block must be erased (to
reset all bits to the one state). This means that other valid data within the
block must be moved for it to persist. NOR flash memory can typically be
programmed a byte at a time, whereas NAND flash memory must be programmed in
multi-byte bursts (typically, 512 bytes).
The process of erasing a block differs between the two memory types. Each
requires a special Erase operation that covers an entire block of the flash
memory. NOR technology requires a precursor step to clear all values to zero
before the Erase operation can begin. An Erase is a special operation
with the flash device and can be time-consuming. Erasing is an electrical
operation that drains the electrons from each cell in an entire block.
NOR flash devices typically require seconds for the Erase operation,
whereas a NAND device can erase in milliseconds. A key characteristic of flash
devices is the number of Erase operations that can be performed. In a NOR
device, each block in the flash memory can be erased up to 100,000 times. NAND
flash memories can be erased up to one million times.
Flash memory challenges
In addition to and as a result of the constraints explored in the previous
section, managing flash devices presents several challenges. The three most
important are garbage collection, managing bad blocks, and wear leveling.
Garbage collection
Garbage collection is the process of reclaiming invalid blocks (those that
contain some amount of invalid data). Reclamation involves moving the valid
data to a new block, and then erasing the invalid block to make it available.
This process is commonly done in the background or as needed, if the file
system is low on available space.
Managing bad blocks
Over time, flash devices can develop bad blocks through use and can even
ship from the manufacturer with blocks that are bad and cannot be used. You can
detect the presence of back blocks from a failed flash operation (such as an
Erase) or an invalid Write operation (discovered through an invalid Error
Correction Code, or ECC).
After bad blocks have been identified, they are marked within the flash
itself in a bad block table. How this is done is device-dependent but can be
implemented with a separate set of reserved blocks managed separately from
normal data blocks. The process of handling bad blocks—whether they ship with
the device or appear over time—is called bad block management. In some
cases, this functionality is implemented in hardware by an internal
microcontroller and is therefore transparent to the upper-level file system.
Wear leveling
Recall that flash devices are consumable parts: You can perform a finite
number of Erase cycles on each block before the block becomes bad (and must
therefore be tagged by bad block management). To maximize the life of the
flash, wear-leveling algorithms are provided. Wear leveling comes in two
varieties: dynamic wear leveling and static wear leveling.
Dynamic wear leveling addresses the problem of a limited number of Erase
cycles for a given block. Rather than randomly using blocks as they are
available, dynamic wear-leveling algorithms attempt to evenly distribute the
use of blocks so that each gets uniform use. Static wear-leveling algorithms
address an even more interesting problem. In addition to a maximum number of
Erase cycles, certain flash devices suffer from a maximum number of Read cycles
between Erase cycles. This means that if data sits for too long in a block and
is read too many times, the data can dissipate and result in data loss. Static
wear-leveling algorithms address this by periodically moving stale data to new
blocks.
System architecture
So far, I've explored flash devices and their fundamental challenges. Now,
look at how these pieces come together as part of a layered architecture (see
Figure 1). At the top is the virtual file system (VFS), which presents a common
interface to higher-level applications. The VFS is followed by the flash file
system, which will be covered in the next section. Next is the Flash
Translation Layer (FTL), which provides for overall management of the flash
device, including allocation of blocks from the underlying flash device as well
as address translation, dynamic wear leveling, and garbage collection. In some
flash devices, a portion of the FTL can be implemented in hardware.
The Linux kernel uses the Memory Technology Device (MTD) interface, which
is a generic interface for flash devices. The MTD can automatically detect the
width of the flash device bus and the number of devices necessary for
implementing the bus width.
Flash file systems
Several flash file systems are available for Linux. The next sectionsexplain the design and advantages of each.
Journaling Flash File System
One of the earliest flash file systems for Linux is called the Journaling
Flash File System. JFFS is a log-structured file system that was designed
for NOR flash devices. It was unique and addressed a variety of problems with
flash devices, but it created another.
JFFS viewed the flash device as a circular log of blocks. Data written to
the flash is written to the tail, and blocks at the head are reclaimed. The
space between the tail and head is free spacewhen this space becomes low, the
garbage collector is executed. The garbage collector moves valid blocks to the
tail of the log, skips invalid or obsolete blocks, and erases them (see Figure
2). The result is a file system that is automatically wear leveled both
statically and dynamically. The fundamental problem with this architecture is
that the flash device is erased too often (instead of an optimal erase
strategy), which wears the device out too quickly.
When a JFFS is mounted, the structural details are read into memory, whichcan be slow at mount-time and consume more memory than desired.
Journaling Flash File System 2
Although JFFS was very useful in its time, its wear-leveling algorithm
tended to shorten the life of NOR flash devices. The result was a redesign of
the underlying algorithm to remove the circular log. The JFFS2 algorithm was
designed for NAND flash devices and also includes improved performance with
compression.
In JFFS2, each block in the flash is treated independently. JFFS2 maintains
block lists to sufficiently wear-level the device. The clean list represents
blocks on the device that are full of valid nodes. The dirty list contains
blocks with at least one obsoleted node. Finally, the free list represents the
blocks that have been erased and are available for use.
The garbage collection algorithm can then intelligently decide what to
reclaim in a reasonable way. Currently, the algorithm probabilistically selects
from the clean or dirty list. The dirty list is selected 99 percent of the time
to reclaim blocks (moving the valid contents to another block), and the clean
list is selected 1 percent of the time (simply moving the contents to a new
block). In both cases, the selected block is erased and placed on the free list
(see Figure 3). This allows the garbage collector to re-use blocks that are
obsoleted (or partially so) but still move data around the flash to support
static wear leveling.
Yet Another Flash File System
YAFFS is another flash file system developed for NAND flash. The initial
version (YAFFS) supported flash devices with 512-byte pages, but the newer
version (YAFFS2) supports newer devices with larger page sizes and greater
Write constraints.
In most flash file systems, obsolete blocks are marked as such, but YAFFS2
additionally marks blocks with monotonically increasing sequence numbers. When
the file system is scanned at mount time, the valid inodes can be quickly
identified. YAFFS also maintains trees in RAM to represent the block structure
of the flash device, including fast mounting through checkpointing —the
process of saving the RAM tree structure to the flash device on a normal
unmount so that it can be quickly read and restored to RAM at mount time (see
Figure 4). Mount-time performance is a great advantage of YAFFS2 over other
flash file systems.
Read-only compressed file systems
In some embedded systems, there's no need to provide a mutable file system:
An immutable one will suffice. Linux supports a variety of read-only file
systems, two of the most useful are cramfs and SquashFS.
Cramfs
The cramfs file system is a compressed read-only Linux file system that can
exist within flash devices. The primary characteristics of cramfs are that it
is both simple and space-efficient. This file system is used in small-footprint
embedded designs.
While cramfs metadata is not compressed, cramfs uses zlib compression on a
per-page basis to allow random page access (pages are decompressed upon
access).
You can play with cramfs using the mkcramfs utility and the loopbackdevice.
SquashFS
SquashFS is another compressed read-only Linux file system that is useful
within flash devices. You'll also find SquashFS in numerous Live CD Linux
distributions. In addition to supporting zlib for compression, SquashFS uses
Lembel-Ziv-Markov chain Algorithm (LZMA) for improved compression and speed.
Like cramfs, you can use SquashFS on a standard Linux system withmksquashfs and the loopback device.
Going further
Like most of open source, software continues to evolve, and new flash file
systems are under development. An interesting alternative still in development
is LogFS, which includes some very novel ideas. For example, LogFS maintains a
tree structure on the flash device itself so that the mount times are similar
to traditional file systems, such as ext2. It also uses a wandering tree for
garbage collection (a form of B+tree). What makes LogFS particularly
interesting, however, is that it is very scalable and can support large flash
parts.
With the growing popularity of flash file systems, you'll see a
considerable amount of research being applied toward them. LogFS is one
example, but other options, such as UbiFS, are also growing. Flash file systems
are interesting architecturally and will continue to be a source of innovationin the future.
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）