beparas

UsrMove

2012-02-07T16:24:00.001+05:30

https://fedoraproject.org/wiki/Features/UsrMove
http://www.freedesktop.org/wiki/Software/systemd/TheCaseForTheUsrMerge
http://lists.busybox.net/pipermail/busybox/2010-December/074114.html

Android Link's

2011-12-28T15:51:00.002+05:30

Android Booting

http://www.androidenea.com/2009/06/android-boot-process-from-power-on.html

http://www.androidenea.com/2009/08/init-process-and-initrc.html

http://www.vogella.de/articles/AndroidInternals/article.html

http://blog.csdn.net/loughsky/article/details/3293922

-----------------------------------------------------------------------------------------------------------------

http://honeypod.blogspot.com/2007/12/initialize-libc-for-android.html

http://discuz-android.blogspot.com/search/label/Bionic%20libc

Evolution of shells in Linux

2011-12-16T12:37:00.001+05:30

Pointing and clicking is fine for most day-to-day computing tasks, but to really take advantage of the strengths of Linux over other environments, you eventually need to crack the shell and enter the command line. Lots of command shells are available, from Bash and Korn to C shell and various exotic and strange shells. Learn which shell is right for you.

read more...

Manage System Startup and Boot Processes on Linux with Upstart

2011-12-14T12:18:00.000+05:30

Want to start, stop, and manage services on your Linux box? Then you need to familiarize yourself with Upstart and take control of your startup and boot processes on Linux.
When Linux boots up, the first process that runs is called init. From there, init takes the task of starting up system processes. But which init? Turns out, there are several flavors of init, and it depends on which Linux distribution you're using and how modern the release is. Let's take a look at some of the backstory.

BSD, System V, Upstart and systemd `init`, Oh My...

You might think that the way that the system starts would be fairly well-agreed upon between Linux distributions. Unfortunately, that's not been the case and may not be the case for some time.

Linux isn't directly derived from UNIX, but it takes a lot of ideas from UNIX, including the way that the system starts. Some Linux distros, most notably Slackware, used the BSD-style init. Slackware (and its derivatives) is the lone holdout for this style these days, and it includes a System V init compatibility workaround so that applications that expect to support System V init scripts can install them normally.
System V (from UNIX System V), the precursor to was the standard for most Linux distros for many years. Distros using SysV init would have several directories under /etc such as rc0.d, rc1.d, through rc6.d for each runlevel — though many of the runlevels are not really implemented.
What's a runlevel, you ask? Essentially this is the grouping of services that are run by init. For example, runlevel 0 is "halt," runlevel 1 or S are the "single user mode," and runlevel 6 is reboot. On Fedora/Red Hat systems, runlevel 3 is a full set of services to run a multiuser system (networking, etc.), and runlevel 5 includes multiuser services and X11 with the display manager. You'll notice I didn't mention 2 or 4, because those runlevels are rarely used and runlevel 4 isn't even defined by default.
Note that you can switch between runlevels using the telinit command, like so: telinit 3 would switch to runlevel 3, and telinit 6 would tell the system to reboot. Note that you would usually want to just use reboot instead to reboot, but telinit 6 would also work.
Under each of the directories, you'd have a set of symbolic links that point back to scripts that include startup and shutdown directives for services like Apache and the SSH daemon. Each link has a name like KNNsshd or SNNcups, where the NN determines the order in which services are killed (K) or started (S). This became tricky with laptops and mobile systems, because the state of a computer might determine the order in which services should be started. See the rationale for Upstart by Scott James Remnant for more detail — but the short of it is that the SysV style init that served Linux well for many years became rather fragile and creaky when Linux adapted to use as a notebook OS as much as a server OS.
So now we have, or had, Upstart as the emerging standard. For now, Upstart is the sort-of standard for several distros. Upstart is used by Ubuntu, current Fedora releases, and openSUSE 11.3 includes it as an optional package. But the Fedora folks are working on a replacement for Upstart called systemd, which is a "system and session manager" that is meant to be a "drop-in replacement for sysvinit." There's a very detailed discussion of the rationale behind systemd by Lennart Poettering that is an interesting read if you're interested in the deep details. So at some point, you'll need to know Upstart or systemd, or both if you are managing systems using Upstart and systemd.
For now, we're going to look at Upstart.

Managing Startup Services

Now, when we're talking about startup services, I mean the system-wide services like SSH and Apache, not the applications started up by your desktop. That's a whole different kettle of fish, and depends on the desktop that you're using. For example, if you're running a recent Linux distro with GNOME, you'll look at System -> Preferences -> Startup Applications.
For applications managed with Upstart, you'll first want to look at the initctl command. This allows you to work with Upstart's init daemon. Naturally, you're going to need to use sudo to run initctl or be logged in as root.
To see what's running on your system, use initctl list. You'll see something like this:

alsa-mixer-save stop/waiting
avahi-daemon start/running, process 690
mountall-net stop/waiting
rc stop/waiting
rsyslog start/running, process 482
screen-cleanup stop/waiting
tty4 start/running, process 859
udev start/running, process 334
upstart-udev-bridge start/running, process 304
ureadahead-other stop/waiting

This is from a system running Ubuntu 10.10, you'll see a different list of jobs on Fedora 14 or another distro. The first field is the name of the job — like rsyslog. The second field is the "goal" of the job, followed by the state of the job.
To stop a job that's running, use initctl stop job. To start a job, run initctl start job. You can also request status of jobs with initctl status job. Finally you can restart or reload jobs with the restart and reload commands. What's the difference between restarting and reloading? Restarting does what it says on the tin — stops the job and then restarts it. The reload command sends the SIGHUP signal to the job, which can be used to tell a daemon to re-read its configuration.
For jobs that are managed by Upstart, you can edit their configuration file under /etc/init. They will have a few lines that describe which runlevels to start/stop on like so:

start on runlevel [2345]
stop on runlevel [!2345]

Change the runlevels as necesary.
If you're using a desktop system, you'll want to install the Boot-up Manager — a GUI tool for handling runlevel configuration. The package is bum, and it will let you manage jobs and configure services by runlevel. It's simple to use, and shouldn't require a lot of guidance.
Note that Fedora uses Upstart in SysV compatibility mode, which means that a lot of jobs on Fedora are not managed with native Upstart scripts. For those jobs you'll want to use the service command.
To see the status of all jobs on Fedora using service run:
service --status-all
This will show which jobs are stopped, running, and in a few instances much more information. For example, iptables will spit out its entire set of policies that are running at the moment.
To manage a job with service use service servicename command. The servicename is the name of the configuration script under /etc/init.d. For example, to start and stop the openSSH daemon, you'll use service sshd start or service sshd stop.
If you want to tweak the services by runlevel, use the chkconfig command. You'd use something like chkconfig --level 35 cups on to tell chkconfig to make sure that cups is started in runlevels 3 and 5.
What if you want to add a service or modify the scripts for existing services? One quick and dirty way is to use /etc/rc.local. The script should be run during any startup or change of runlevel. Another way is to modify the scripts under /etc/init.d (for SysV compatibility) or /etc/init (native Upstart scripts) or write your own for a new service.
Typically, this is unnecessary — almost any service that you'll be using should have init scripts pre-written. Writing an init script, whether for Upstart or for SysV, is a bit outside the scope of this tutorial.
Since many users are going to be transitioning to systemd, we'll take a longer look at managing jobs with systemd when Fedora 15 comes out.
Most of the time, your interaction with managing services should be minimal unless you're working with Linux as a full-time admin. If you are doing system administration, or planning to, you should already be familiar with the init system that your distros are using. If not, now's a good time to learn. If you're a desktop Linux user, you probably won't be managing services very often, but it's a good to know the basics that we've covered here in case you need to do any troubleshooting or just want to fine-tune your system.

Ref: https://www.linux.com/learn/tutorials/404619-manage-system-startup-and-boot-processes-on-linux-with-upstart

https://www.linux.com/learn/tutorials/524577

Vim Tips

2011-10-31T11:14:00.003+05:30

1.I always wished that as a programmer , I should not waste my time in
writing the trivial stuff, the one I require every time I sit to write the
program. For example, while writing any C-program, we have the general
format of #include<...> & then main() { ... return 0 ; }
What if every time I start writing the program, this format is ready for me
?? Well thats possible, atleast with "vim".

Create the standard format of the file you want , lets say at <~/format> is
the path.

Now start vim : vim ,& then type , in command-mode ---> :r
~/format ,thats all , whatever is in the file <~/format> will be simply
pasted .

I have created the file : <~/lic.c> , it contains the GNU GPL disclaimer.
Now after I finish writing the program , I just have to say ( in command
mode ) --> :r ~/lic.c , thats all, the license-terms get pasted .
It looks like this :
/* ########################################################################
*
*LAST UPDATED :

*Copyright (C) 2011 Lokesh Walase
*
* Released under GNU General Public License v2.0+ .
* FOR DETAILED LICENSE, SEE THE END OF THIS PROGRAM.
*
*########################################################################
*/

/*####################################################################################################################
*
*This program is free software; you can redistribute it and/or modify
*it under the terms of the GNU General Public License as published by
*the Free Software Foundation; either version 2 of the License, or
*(at your option) any later version.
*
*This program is distributed in the hope that it will be useful,
*but WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*GNU General Public License for more details.
*
* Visit
*
*To receive a copy of the GNU General Public License
* write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
*Boston, MA 02110-1301 USA

*The GNU General Public License does not permit incorporating this program
*into proprietary programs.
*
*
########################################################################################################################
*/

2.As you might have noticed , the <~/lic.c> has the field --> LAST UPDATED
: , now to put the date & time here , go to that line, & in command mode
---> :r !date .

3.Well, if that didnt really raise your eyebrows, here's somemore . What is
the best thing of the "terminal" ?? Yes, it "auto-completes" the commands
by '\t' key. Now what if the same feature of "auto-completion" is present
everywhere & not only in the "terminal" ?? Well thats possible, (again)
atleast with "vim" .

Create a new <.vimrc> file in your home-folder . Say : vim .vimrc , at your
home-folder & then copy paste this code( I found it on net ) :

        *function! Tab_Or_Complete()
          if col('.')>1 && strpart( getline('.'), col('.')-2, 3 ) =~ '^\w'
                  return "\"
             else
                         return "\"
                endif
         endfunction
          :inoremap

=Tab_Or_Complete()
:set dictionary="/usr/dict/words"
*
Pls be sure of the indentation ,everything has to be strictly indented . I
dont know what exactly it is doing .
Now vim will "auto-complete" any words you type , press '\t' for the same .
Its indeed cool ........proud to be a "vimmer" !! ;)

4.Now whats next ?? Well, enough of vim. Recently I came to know of the
command that can convert .pdf files to text-files, post-script files ,
html-files & many more. Just type in the terminal & then you press
'\t' twice to see all the options .
Reading man pages is boring , so u may convert a lengthy man-page to a html
file & get a nice look & feel to read it , I did it for "info flex" .
Type : info flex > flex.odt . Now open flex.odt & get its pdf format , &
then use command --> pdftohtml flex.pdf flex.html

Ref : http://groups.google.com/group/cofsug/browse_thread/thread/d5edacf343486d03?hl=en-GB

How do I make changes to a package and capture them using ltib

2011-10-19T10:48:00.000+05:30

1. Unpack the sources and apply all current patches:

./ltib -m prep -p u-boot

2. Edit/add files under rpm/BUILD/package/
3. Build the package with your changes:

./ltib -m scbuild -p u-boot

4. Once the package builds successfully, check the install phase:

./ltib -m scinstall -p u-boot

5. Test your package before committing the changes:

./ltib -m scdeploy -p u-boot

6. Repeat steps 2 -> 5 until you are satisfied with your results.

Ref:  http://ltib.org/documentation-LtibFaq

2011-09-26T13:20:00.001+05:30

Linux kernel's Suspend/Resume mode.
Ref:
http://kzjblog.appspot.com/2010/11/20/suspend-en.html
http://technothirst.blogspot.com/2010/11/turn-off-android-power-management-from.html

Programming tips

2011-09-16T10:01:00.000+05:30

Why not to use gets() in Linux ?
Ans: http://c.ittoolbox.com/groups/technical-functional/c-l/store-character-string-containing-spaces-using-structure-4414903
-----------------------------------------------------------------

Command to change vdi's uuid.
$ VBoxManage internalcommands setvdiuuid disk.vdi
-----------------------------------------------------------------

LDD3 examples

-----------------------------------------------------------------

C Programming

http://codingrelic.geekhold.com/search/label/C%20Programming

ssh login problem

2011-07-25T10:42:00.001+05:30

Problem: When I try to connect target board using ssh, it gives me error of 'password has expired'. The log is given below.

-------------------------------------------------------------------------------

$ ssh root@192.168.1.142
root@192.168.1.142's password:
WARNING: Your password has expired.
You must change your password now and login again!
Changing password for root
New password:
Bad password: too short
Retype password:
Password for root changed by root
Connection to 192.168.1.142 closed.
---------------------------------------------------------------------------------

Soln: change the entry in shadow file,
old entry: root:$1$bmWHS8dA$cWZORf5md8ecQbEvL.Ule.:0:0:99999:7:::
new entry: root:$1$bmWHS8dA$cWZORf5md8ecQbEvL.Ule.:11851:0:99999:7:::

The problem is in shadow file, in this 'days since last password changed' field is set 0, so change modify it.

Ref: http://lists.busybox.net/pipermail/buildroot/2011-March/042165.html

Interview

2011-05-20T19:21:00.002+05:30

Ken Thompson's Interview

Dennis Ritchie's Interview

Linus Torvalds

@ LinuxCon Europe 2011

http://www.muktware.com/news/2855

ioctl

2011-05-20T11:34:00.000+05:30

Q] Why ioctl() operation is removed form Linux Kernel 2.6.36?
Ans: When ioctl was executed, it took the Big Kernel Lock (BKL), so nothing else could execute at the same time. This is very bad on a multiprocessor machine, so there was a big effort to get rid of the BKL. First, unlocked_ioctl was introduced. It lets each driver writer choose what lock to use instead. This can be difficult, so there was a period of transition during which old drivers still worked (using ioctl) but new drivers could use the improved interface (unlocked_ioctl). Eventually all drivers were converted and ioctl could be removed.
compat_ioctl is actually unrelated, even though it was added at the same time. Its purpose is to allow 32-bit userland programs to make ioctl calls on a 64-bit kernel. The meaning of the last argument to ioctl depends on the driver, so there is no way to do a driver-independent conversion

मराठी भाषेची ताकद

2011-01-14T16:48:00.001+05:30

खालील २ लेखात, प्रत्येक शब्द 'क' आणि 'प' पासून सुरु करुन येवढा मोठा परिच्छेद लिहिला आहे.

------------------------------------------------ ---------------------------

केव्हातरी कोल्हापूरच्या कर्तव्यतत्पर केळकर काकांबद्दल काकांच्याच कचेरीतल्या केशवने काकूंसमोर कागाळी केली. काकू कावल्या. काकूंनी कपाटातून कात्री काढून काकांच्या कामाचे कोरे करकरीत कागद कचाकचा कापले. काकांचे कापलेले कागद केशवानेच कचऱ्यात कोंबून काकांच्याच किचनमध्ये 'कजरारे-कजरारे' कवितेवर कोळीनृत्य केले.
काकूंनी कागद कापल्याचे कळताच काका कळवळले. काकांनीही कमालच केली. काकांनी काकूंचे काळे कुळकुळीत केस कात्रीने कराकरा कापले. काका काय करताहेत काकूंना कळेनाच! काकूंनी कर्कश्श किंचाळून कलकलाट केला.
काका काकूंची कसली काळजी करणार! काकांना कामाची काळजी. काकूंच्या कर्णकर्कश्श कोलाहलातही, केशवाने कचऱ्यात कोंबलेले कागदाचे कपटेन कपटे काढून काकांनी कचेरीकडे कूच केले.
कचेरीच्या कामासाठी काकांनी कंबर कसली. कागदाच्या कापलेल्या कपट्यांचे काकांनी 'कोलाज'
करून कामकाज कार्यान्वयित केले. केशवाचे कारनामे कळताच काकांनी काट्यानेच काटा काढला.
काकांनी केशवालाच कोलाजचे काम करण्यासाठी कुथवला. कपटी केशवने काकांवरच कामचुकारपणाचा
कांगावा करून कामाचा कंटाळा केला. काकांनी कठोरपणे केशवाला कामावरून काढले. कासावीस काकूंनी कालच्या कडू कारल्याची कोशिंबीर कटाप करून काकांसाठी कच्च्या कैरीचे कोय काढून कालवण केले. काकांनीही करुणेने काकूंचे कृत्रिम केस कुरवाळले. केळकरांच्या कोकणस्थ कुटुंबात कर्तव्यापुढे कर्मकांड केव्हाही कनिष्ठच. कर्तव्यदक्ष काकांच्या कार्यकाळात कचेरीने कर्मरूपी किल्ल्याचे कीर्तिशिखर काबीज केले.
कामावरून काढलेल्या केशवाने कितीतरी काबाडकष्ट काढल्यावर कोल्हापूरच्या कॉम्रेड कणेकर
कॉलेजने केशवाला कबड्डीचा कर्णधार केला. क्रिडापटू केशवाने कबड्डीतच करियर केले. कालच्या कागाळीखोर केशवाला काळानेच केला 'कबड्डीतल्या किचकट कसरतींचा कर्ता'!
कथासार
-
क्रियेविण करिता कथन, किंवा कोरडेची कीर्तन,
कितीक किताब कष्टाविण, काय कामाचे

------------------------------------------------ ---------------------------------

परवा पुराण-प्रसिद्ध पखवाज पंडित पुरोहित पंतांची पिवळी पगडी पुरंदरच्या पंधराशेव्या पायरीवरून पुण्यात पर्वतीच्या पाचव्या पायरीपाशी पर्णकुटीपासून पंधरा पावलांवर पहुडलेल्या पंकजच्या पोटावर पटकन पडली. पगडी पडलेली पाहताच पंत पुरंदरच्या पायथ्याशी पोलिसठाण्यात पळाले. पुरंदरच्या पोलिसांनी पंतांना पुण्याच्या पोलिसांकडे पाठवले.

पंत पुण्यात पोहोचताच पोलिसांवर पेटले. पंत पेटल्यामुळे पोलिस पटकन पर्वतीकडे पळाले. पांढर्‍या पोषाखातल्या पोलिसांना पाहून पंकज पर्वतीच्या पलिकडे पळाला. पोलिसांनी पंकजचा पिच्छा पुरवला.

पळता पळता पंकज पाण्याच्या पाँडमध्ये पडला. पंतांनीच पाण्यात पोहून पंकजला पकडले. पिवळी
पगडी पण पकडली. पोलिसांनी पंकजला पोलिसठाण्याकडे पिटाळले. पकडणारा पोलिस पदपथावर
पाय पसरून पडला. पोलिस पडलेला पाहून पंकज पाठीवर पांघरूण पांघरून पळाला.

पंतांनी पुरंदरला पोहोचताच पगडीत पंकजचे पैशांचे पाकिट पाहिले. पाकिटातले पुष्कळ पैसे पंतांनी
पनवेलला पुत्राला पोस्टाने पाठवले. पंतांच्या पाजी पुत्राने पैशांच्या प्राप्तीतून पोटात पंजाबी पदार्थ पचवले.

पंतांना परमेश्वरच पावला!
पंकजला पकडण्यासाठी पंतांसोबत पुण्यात पोहोचलेली पंतांची पोरगी प्राची पंकजला पहिल्यांदा पाहताच पंकजच्या प्रेमात पडली. प्राचीने पंकज,पोलिसांची पकडा पकडी पाहिली. पंकजचा पदपथावरून पोबाराही पाहिला. पानशेतच्या पुराच्या पाण्यामुळे पुनर्वसित पंकज परत पर्णकुटीत पोहोचला.

पित्यासमवेत प्राची पुरंदरला परतली, पण पंतांनी पंकजच्या पाकिटातल्या पैशांबाबत पंक्ति-प्रपंच पाळला. पुष्कळ पैसे पुत्राला पाठवले. पंतांच्या पुन्हा पुन्हा पिडणार्‍या पुराणांच्या पोपटपंचीमुळे प्राची पेटली.

पंकजच्या प्रेमाखातर प्राची पुण्यास परतली. प्राचीनेच पंकजवरच्या पोलिसांच्या पंचनाम्याला पाने पुसली. पंकजला पहायला प्राची परत पर्णकुटीपाशी पोहोचली. पण पर्णकुटीत पहुडलेल्या पंकजचे पाय पळून पळून पांढरे पडलेले! प्राचीने पंकजच्या पायावर पिवळे पुरळही पाहिले.

पंकजची परिस्थिती पाहून प्राण पिळवटलेल्या प्राचीने पदर पाण्यात पिळून पंकजचे पाय पुसले. प्राचीचा प्रथमोपचार पाहून पंकजला पोरगी पसंत पडली. पंकजने प्राचीला पर्णकुटीतच पटवले. पर्णकुटीतील प्रेम-प्रकरण पाहून पर्णकुटीच्या पायर्‍यांवर पत्ते पिसणारी पोरे पूर्व-पश्चिमेला पांगली. प्राचीने पंकजचे पा़किट पैशांविनाच परतवले. परंतू प्रेमात पारंगत पंकजने प्राचीस पाच पाप्या परतवल्या.

पंतांना परमेश्वर पावला, पण पंकजला पंतांची पायाळू पोर पावली.

Translation Limits

2010-08-09T11:55:00.003+05:30

The term "translation limits" refers to the minimum numbers of various element that a C compiler must be able to handle. These include such things as the length of identifiers, levels of nesting, number of case statements, and a number of member allowed in structure or union. C99 has increased several of these limits beyond the already generous ones specified by C89. Here are some examples:

Limit                                                                       C89      C99
Nesting levels of blocks                                         15        127
Nesting levels of conditional inclusion                  8        63
Significant characters in an internal identifier   31        63
Significant characters in an external identifier      6          31
Members of a structure or union                         127      1023
Arguments in a function call                                31        127
Numbers of case statement in switch                 257     1023

Ref: C, The Complete Reference by Herbert Schildt (Fourth Edition)

-----------------------------------------------------------------------------------------------------------------------

Some good c-examples

c_program_examples

NAND Types

2010-03-13T09:58:00.000+05:30

There are various types of NAND Flash available. Bare NAND chips, SmartMediaCards, DiskOnChip.
SmartMediaCards are bare NAND chips covered by thin plastic. They are very common in digital cameras and MP3 players. The card itself contains nothing smart at all. It gets smart by software.
DiskOnChip is NAND Flash with additional glue logic as a drop in replacement for NOR Flash chips. The glue logic provides direct memory access to a small address window, which contains a boot loader stub, which loads the real boot code from the NAND device. The logic contains also control registers for the static NAND chip control lines and a hardware ECC generator.

Ref: http://www.linux-mtd.infradead.org/doc/nand.html

Linux in Hollywood

2010-01-28T12:34:00.001+05:30

http://digitalcontentproducer.com/dcc/revfeat/video_linux_hollywood/

http://www.dslreports.com/forum/r23640073-Avatar-Movie-Made-Possible-With-Linux

Video Links

2009-09-05T16:33:00.006+05:30

Schedule Notifications With Libnotify and At

Using Regular ftp With Konqueror

Advanced Firefox Configuration

Protect Files with chattr

Disabling the Root Account on Your SSH Server

Access Remote GUI Programs Using SSH Forwarding

Configuring CUPS Printers Using a Web Browser

Welcome script

2009-06-11T11:19:00.008+05:30

This is simple welcome script, asking for User selection.

dialog --title "Welcome to Messung System " --menu "\nChose the user" 11 30 2 1 "messung" 2 "root" 2>.welcome Q_MUSIC=$(cat .welcome)
This dialog box gives you two option, one is enter as Messung user or switch to Root user.

if [ "$Q_MUSIC" = "1" ]; then dialog --msgbox "Hit Enter to continue" 5 25
clear
else #dialog --passwordbox "Enter the Password :" 12 25 dialog --infobox "Enter the Password " 3 25 su -l
fi

If you go for first option, then you login as a Messung user. Then welcome dialog box will appear, given below.

If you go for second option, then it will ask for password.

The welcome window for Root user is given below.

NAND Types

2009-06-03T11:14:00.000+05:30

There are various types of NAND Flash available. Bare NAND chips, SmartMediaCards, DiskOnChip.

SmartMediaCards are bare NAND chips covered by thin plastic. They are very common in digital cameras and MP3 players. The card itself contains nothing smart at all. It gets smart by software.

DiskOnChip is NAND Flash with additional glue logic as a drop in replacement for NOR Flash chips. The glue logic provides direct memory access to a small address window, which contains a boot loader stub, which loads the real boot code from the NAND device. The logic contains also control registers for the static NAND chip control lines and a hardware ECC generator.

Ref: http://www.linux-mtd.infradead.org/doc/nand.html

Tips & Tricks

2009-05-18T12:34:00.046+05:30

Console-based calculator
To build a terminal-based calculator, add the following function to your ~/.bashrc file:
function calc
{
echo “${1}”|bc -l;
}
Reload Bash profile using the following command:
$source .bashrc
Now run calc from terminal as:
$ calc 4+7*9-10/5
You will get the following output:
65.00000000000000000000
Easy enough?

-----------------------------------------------------------

When did I execute a command?
Here is a tip that will help you understand when you did what. history will give the list of commands which your have executed earlier. If you want information on when you executed these commands, you need to do the following.
Open the /etc/bashrc file in a text editor and add
the following:
export HISTTIMEFORMAT=”%h/%d - %H:%M:%S “
After adding this line, re-login and execute the history command again. Now you will see the commands along with their time of execution.

-----------------------------------------------------------

Encrypt your file with Vim
Did you know Vim can help you encrypt your file so that no one can open it without knowing the encryption key? Well, all you need to do is to create a file
with the -x flag:
vim -x filename

The above command will prompt you for an encryption key. Provide the key and remember it, as you will need it to open the file from now on.

-----------------------------------------------------------

Using Vi’s .exrc file
As you know the ~/.exrc file is used for making permanent settings to your Vi editor. If you place the following commands in this file, these commands will
be available to all your subsequent Vi sessions:

1) :abb is for abbreviation
For example:
:abb etl Elitecore Technologies Limited, Ahmedabad

So whenever you type etl in your Vi editor and press ENTER, SPACE or TAB, etl will be replaced by
“Elitecore Technologies Limited, Ahmedabad”
I use it to create templates for C and C++ programs, like:
:abb CPP #include^M using namespace std;^M int
main()^M {^M return0;^M }

Here ^M is for a new line. Note that to make sure you do not type ^M, for a new line you have to:
a) ctrl+v
b) press ENTER
It will display ^M as above but it means a new line.
So, now every time I need a C++ template, I just type CPP and press ENTER, SPACE or TAB.

2) :map is for mapping some command to some
shortcut.
For example, the vi command :set number is used to display line numbers in a file for every new line. Let’s say we want to set a shortcut for it, say, F2. To map this command to shortcut key, the Vi setting will be:
:map #2 :set number^M

Same for :set nonumber; let’s set it to F3:
:map #3 :set nonumber^M

3) set tabstop=2 is for setting TAB. I want TAB to be equal to 2 spaces, so I set it to 2.

-----------------------------------------------------------

Read a CD volume label
To read the volume label of a CD-ROM from the terminal:
$ dd if=/dev/cdwriter bs=1 skip=32808 count=32
LFYCD_MARCH08 32+0 records in
32+0 records out
32 bytes (32 B) copied, 4.02731 seconds, 0.0 kB/s
Note: The value, /dev/cdwriter depends on your device file.

-----------------------------------------------------------

Disabling ‘shutdown’ with Ctrl+Alt+Del

If you get annoyed, when you accidentally reboot the system by pressing the three magic keys, comment out the following line in your /etc/inittab file:

ca::ctrlaltdel:/sbin/shutdown -t3 -r now

You may alternatively allow specific users with this capability by changing the line as below and adding the specific login ids in ‘/etc/shutdown.allow’,

ca::ctrlaltdel:/sbin/shutdown -a -t3 -r now

-----------------------------------------------------------

More passwd flags
You can change user account details using the passwd command—yes, it can do more than changing just the password. Open the new terminal and enter the
following commands:

passwd -d [user_name]

where -d deletes the user’s password.
Some other useful flags are:

-l locks the user account
-u unlocks the user’s account
-? is to get help

Ref: Linux For You May 2009

-----------------------------------------------------------

Extract the contents of an RPM
Sometimes we are required to extract the files inside an RPM file instead of installing the RPM. A good example is when we take binaries from one distribution and to use on another distribution, where RPM is not the default
package manager. The rpm2cpio command comes in handy under these circumstances. For example:
$rpm2cpio coreutils-6.9-2.fc7.i386.rpm |cpio -idv
./bin/basename
./bin/cat
./bin/chgrp
./bin/chmod
[...]
This command can be used for source RPMs also.

-----------------------------------------------------------

Checking memory and I/O
The vmstat utility provides interesting information about processes, memory, I/O and CPU activity. When you run this utility without any arguments, the output looks similar to the following:
procs memory swap io system cpu
rbw swpd free buff cache si so bi bo in cs us sy id
000 8 8412 45956 52820 0 0 0 0 104 11 66 0 33
Here, the ‘procs’ fields show the number of
processes:

Waiting for run time (r)
Blocked (b)
Swapped out (w)

The 'memory' fields show the KBs of:

Swap memory
Free memory
Buffered memory
Cached memory

The 'swap' fields show the KBps of memory:

Swapped in from disk (si)
Swapped out to disk (so)

The 'io' fields show the number of blocks per second:

Sent to block devices (bi)
Received from block devices (bo)

The 'system' field shows the number of:

Interrupts per second (in)
Context switches per second (cs)

The 'cpu' field shows the percentage of total CPU
time as:

User time (us)
System time (sy)
Idle (id) time

If you want vmstat to update informationautomatically, you can run it as vmstat nsec, where nsec is the number of seconds you want it to wait before
another update.

-----------------------------------------------------------

Displays information about ELF files.

$readelf --segments /bin/ls
$readelf --segments /lib/libc.so.6

-----------------------------------------------------------

Execute a program periodically

$watch -n1 "cat /proc/interrupts"

-----------------------------------------------------------

Find the memory used by a program / process using pmap command

You can find the memory used by a program / process by looking into /proc/[process pid]/maps.
You can use pamp command for same.

$pmap pid

-----------------------------------------------------------

Run your script at boot time

To run your script at boot time you need to first copy your script to the /etc/init.d directory

$ cp /etc/init.d

Now make it executable as follows.

$chmod +x

Create a link to script for all run levels that you want your script to run.

$ ln -s /etc/init.d/ /etc/rc.d/rc5.d/S85
$ ln -s /etc/init.d/ /etc/rc.d/rc5.d/K85

The name of each symbolic link begins with either a K or S. K links are process that are killed on that runlevel, while those beginning with S are started. The S85 tells the system to start the script after starting all scripts with a lower no. & so is the case while killing at shutdown.

Ref: Q & A section, Linux For You, July 2009.

-----------------------------------------------------------

In Shell Scripting, How to find the length of variable.

$ test="Hello World"
$ echo ${#test}
11................................................. o/p

Ref: Linux Journal, May 2009.

-----------------------------------------------------------

How To Enable Root User ( Super User ) in Ubuntu

How To Login Without Entering Username and Password

-----------------------------------------------------------

wet tips

-----------------------------------------------------------

Internet

Find the internet connection speed.

How to identify Public IP address of your internet connection and ISP details.

-----------------------------------------------------------

VIM

8 Essential Vim Editor Navigation Fundamentals

-----------------------------------------------------------

How to find and delete empty directories and files

Find empty directories in the current directory using find -empty

$ find . -type d -empty

Remove all empty directories under the current directory

$ find . -type d -empty -exec rmdir {} \;

Find empty files in the current directory using find -empty

$ find . -type f -empty

How many empty files are located under the current directory

$ find . -type f -empty | wc -l

How many non-empty files are located under the current directory

$ find . -type f -not -empty | wc -l

Find dead symbolic links

$ find . -type l | perl -lne 'print if ! -e'

-----------------------------------------------------------

HowTo: Linux / UNIX Create a Manpage

-----------------------------------------------------------

View information about the motherboard and CPU

$ dmidecode | more

demdecode's purpose is to report "information

about your system's hardware as described in your

system BIOS"

-----------------------------------------------------------

How to count how many processes each user is running in Linux

$ ps hax -o user | sort | uniq -c

ps will list the processes, h will remove the header,
-o user prints only the user column,
sort sorts in alphabetical order, so uniq can count each
occurrence and show the number of occurrences instead of all
the occurrences themselves.

-----------------------------------------------------------

How to find which process is eating RAM

$ ps aux | awk '{print $2, $4, $11}' | sort -k2rn | head -n 20

-----------------------------------------------------------

 Sed tutorials

http://unstableme.blogspot.com/search/label/Sed

-----------------------------------------------------------

cross compiling

http://www.gnu.org/s/hello/manual/libc/Configuring-and-compiling.html

-----------------------------------------------------------

Using Vim as a hex editor

Open a file in vim as usual, hit escape and type:

: %!xxd to switch into hex mode

exit from hex mode

:%!xxd -r

-----------------------------------------------------------

How to see what is in an RPM without installing it?

1. Create a temp directory

# mkdir x

2. Change directory

# cd x

3. Now extract the RPM

# rpm2cpio /path/of/ur/RPM/file.rpm | cpio -dmi

 Ref:  http://www.linuxquestions.org/questions/blog/hi2arun-520846/

how-to-see-what-is-in-an-rpm-without-installing-it-4062/

-----------------------------------------------------------

How to change the  sudo timeout length in Ubuntu

 https://help.ubuntu.com/community/RootSudoTimeout

-----------------------------------------------------------

Disable/Enable Auto-Mount in Ubuntu 10.04/10.10

http://www.liberiangeek.net/2010/09/disableenable-auto-mount-ubuntu-10-0410-10-maverick-meerkat/

Maximum On-Disk Sizes of the Filesystems

2009-04-06T12:15:00.002+05:30

Filesystem File Size Limit Filesystem Size Limit
ext2 with 1 KiB blocksize 16448 MiB 2048 GiB (= 2 TiB)
(~ 16 GiB)

ext2 with 2 KiB blocksize 256 GiB 8192 GiB (= 8 TiB)

ext2 with 4 KiB blocksize 2048 GiB (= 2 TiB) 16384 GiB (= 16 TiB)

ext2 with 8 KiB blocksize (1) 65568 GiB (~ 64 TiB) 32768 GiB (= 32 TiB)

ReiserFS 3.5 (Linux 2.2) 4 GiB 16384 GiB (= 16 TiB)

ReiserFS 3.6 (Linux 2.4) 1 EiB 16384 GiB (= 16 TiB)

XFS 8 EiB 8 EiB

JFS with 512 Bytes blocksize 8 EiB 512 TiB

JFS with 4KiB blocksize 8 EiB 4 PiB

NFSv2 (Client side) 2 GiB 8 EiB

NFSv3 (Client side) 8 EiB 8 EiB

Reference
http://linuxreviews.org/sysadmin/filesystems/

Kbuild

2009-03-03T15:25:00.001+05:30

Linux Kernel Makefiles

This document describes the Linux kernel Makefiles.

=== Table of Contents

=== 1 Overview
=== 2 Who does what
=== 3 The kbuild files
--- 3.1 Goal definitions
--- 3.2 Built-in object goals - obj-y
--- 3.3 Loadable module goals - obj-m
--- 3.4 Objects which export symbols
--- 3.5 Library file goals - lib-y
--- 3.6 Descending down in directories
--- 3.7 Compilation flags
--- 3.8 Command line dependency
--- 3.9 Dependency tracking
--- 3.10 Special Rules
--- 3.11 $(CC) support functions

=== 4 Host Program support
--- 4.1 Simple Host Program
--- 4.2 Composite Host Programs
--- 4.3 Defining shared libraries
--- 4.4 Using C++ for host programs
--- 4.5 Controlling compiler options for host programs
--- 4.6 When host programs are actually built
--- 4.7 Using hostprogs-$(CONFIG_FOO)

=== 5 Kbuild clean infrastructure

=== 6 Architecture Makefiles
--- 6.1 Set variables to tweak the build to the architecture
--- 6.2 Add prerequisites to archprepare:
--- 6.3 List directories to visit when descending
--- 6.4 Architecture specific boot images
--- 6.5 Building non-kbuild targets
--- 6.6 Commands useful for building a boot image
--- 6.7 Custom kbuild commands
--- 6.8 Preprocessing linker scripts

=== 7 Kbuild Variables
=== 8 Makefile language
=== 9 Credits
=== 10 TODO

=== 1 Overview

The Makefiles have five parts:

Makefile the top Makefile.
.config the kernel configuration file.
arch/$(ARCH)/Makefile the arch Makefile.
scripts/Makefile.* common rules etc. for all kbuild Makefiles.
kbuild Makefiles there are about 500 of these.

The top Makefile reads the .config file, which comes from the kernel
configuration process.

The top Makefile is responsible for building two major products: vmlinux
(the resident kernel image) and modules (any module files).
It builds these goals by recursively descending into the subdirectories of
the kernel source tree.
The list of subdirectories which are visited depends upon the kernel
configuration. The top Makefile textually includes an arch Makefile
with the name arch/$(ARCH)/Makefile. The arch Makefile supplies
architecture-specific information to the top Makefile.

Each subdirectory has a kbuild Makefile which carries out the commands
passed down from above. The kbuild Makefile uses information from the
.config file to construct various file lists used by kbuild to build
any built-in or modular targets.

scripts/Makefile.* contains all the definitions/rules etc. that
are used to build the kernel based on the kbuild makefiles.

=== 2 Who does what

People have four different relationships with the kernel Makefiles.

*Users* are people who build kernels. These people type commands such as
"make menuconfig" or "make". They usually do not read or edit
any kernel Makefiles (or any other source files).

*Normal developers* are people who work on features such as device
drivers, file systems, and network protocols. These people need to
maintain the kbuild Makefiles for the subsystem they are
working on. In order to do this effectively, they need some overall
knowledge about the kernel Makefiles, plus detailed knowledge about the
public interface for kbuild.

*Arch developers* are people who work on an entire architecture, such
as sparc or ia64. Arch developers need to know about the arch Makefile
as well as kbuild Makefiles.

*Kbuild developers* are people who work on the kernel build system itself.
These people need to know about all aspects of the kernel Makefiles.

This document is aimed towards normal developers and arch developers.

=== 3 The kbuild files

Most Makefiles within the kernel are kbuild Makefiles that use the
kbuild infrastructure. This chapter introduces the syntax used in the
kbuild makefiles.
The preferred name for the kbuild files are 'Makefile' but 'Kbuild' can
be used and if both a 'Makefile' and a 'Kbuild' file exists, then the 'Kbuild'
file will be used.

Section 3.1 "Goal definitions" is a quick intro, further chapters provide
more details, with real examples.

--- 3.1 Goal definitions

Goal definitions are the main part (heart) of the kbuild Makefile.
These lines define the files to be built, any special compilation
options, and any subdirectories to be entered recursively.

The most simple kbuild makefile contains one line:

Example:
obj-y += foo.o

This tell kbuild that there is one object in that directory, named
foo.o. foo.o will be built from foo.c or foo.S.

If foo.o shall be built as a module, the variable obj-m is used.
Therefore the following pattern is often used:

Example:
obj-$(CONFIG_FOO) += foo.o

$(CONFIG_FOO) evaluates to either y (for built-in) or m (for module).
If CONFIG_FOO is neither y nor m, then the file will not be compiled
nor linked.

--- 3.2 Built-in object goals - obj-y

The kbuild Makefile specifies object files for vmlinux
in the $(obj-y) lists. These lists depend on the kernel
configuration.

Kbuild compiles all the $(obj-y) files. It then calls
"$(LD) -r" to merge these files into one built-in.o file.
built-in.o is later linked into vmlinux by the parent Makefile.

The order of files in $(obj-y) is significant. Duplicates in
the lists are allowed: the first instance will be linked into
built-in.o and succeeding instances will be ignored.

Link order is significant, because certain functions
(module_init() / __initcall) will be called during boot in the
order they appear. So keep in mind that changing the link
order may e.g. change the order in which your SCSI
controllers are detected, and thus your disks are renumbered.

Example:
#drivers/isdn/i4l/Makefile
# Makefile for the kernel ISDN subsystem and device drivers.
# Each configuration option enables a list of files.
obj-$(CONFIG_ISDN) += isdn.o
obj-$(CONFIG_ISDN_PPP_BSDCOMP) += isdn_bsdcomp.o

--- 3.3 Loadable module goals - obj-m

$(obj-m) specify object files which are built as loadable
kernel modules.

A module may be built from one source file or several source
files. In the case of one source file, the kbuild makefile
simply adds the file to $(obj-m).

Example:
#drivers/isdn/i4l/Makefile
obj-$(CONFIG_ISDN_PPP_BSDCOMP) += isdn_bsdcomp.o

Note: In this example $(CONFIG_ISDN_PPP_BSDCOMP) evaluates to 'm'

If a kernel module is built from several source files, you specify
that you want to build a module in the same way as above.

Kbuild needs to know which the parts that you want to build your
module from, so you have to tell it by setting an
$(-objs) variable.

Example:
#drivers/isdn/i4l/Makefile
obj-$(CONFIG_ISDN) += isdn.o
isdn-objs := isdn_net_lib.o isdn_v110.o isdn_common.o

In this example, the module name will be isdn.o. Kbuild will
compile the objects listed in $(isdn-objs) and then run
"$(LD) -r" on the list of these files to generate isdn.o.

Kbuild recognises objects used for composite objects by the suffix
-objs, and the suffix -y. This allows the Makefiles to use
the value of a CONFIG_ symbol to determine if an object is part
of a composite object.

Example:
#fs/ext2/Makefile
obj-$(CONFIG_EXT2_FS) += ext2.o
ext2-y := balloc.o bitmap.o
ext2-$(CONFIG_EXT2_FS_XATTR) += xattr.o

In this example, xattr.o is only part of the composite object
ext2.o if $(CONFIG_EXT2_FS_XATTR) evaluates to 'y'.

Note: Of course, when you are building objects into the kernel,
the syntax above will also work. So, if you have CONFIG_EXT2_FS=y,
kbuild will build an ext2.o file for you out of the individual
parts and then link this into built-in.o, as you would expect.

--- 3.4 Objects which export symbols

No special notation is required in the makefiles for
modules exporting symbols.

--- 3.5 Library file goals - lib-y

Objects listed with obj-* are used for modules, or
combined in a built-in.o for that specific directory.
There is also the possibility to list objects that will
be included in a library, lib.a.
All objects listed with lib-y are combined in a single
library for that directory.
Objects that are listed in obj-y and additionally listed in
lib-y will not be included in the library, since they will
be accessible anyway.
For consistency, objects listed in lib-m will be included in lib.a.

Note that the same kbuild makefile may list files to be built-in
and to be part of a library. Therefore the same directory
may contain both a built-in.o and a lib.a file.

Example:
#arch/i386/lib/Makefile
lib-y := checksum.o delay.o

This will create a library lib.a based on checksum.o and delay.o.
For kbuild to actually recognize that there is a lib.a being built,
the directory shall be listed in libs-y.
See also "6.3 List directories to visit when descending".

Use of lib-y is normally restricted to lib/ and arch/*/lib.

--- 3.6 Descending down in directories

A Makefile is only responsible for building objects in its own
directory. Files in subdirectories should be taken care of by
Makefiles in these subdirs. The build system will automatically
invoke make recursively in subdirectories, provided you let it know of
them.

To do so, obj-y and obj-m are used.
ext2 lives in a separate directory, and the Makefile present in fs/
tells kbuild to descend down using the following assignment.

Example:
#fs/Makefile
obj-$(CONFIG_EXT2_FS) += ext2/

If CONFIG_EXT2_FS is set to either 'y' (built-in) or 'm' (modular)
the corresponding obj- variable will be set, and kbuild will descend
down in the ext2 directory.
Kbuild only uses this information to decide that it needs to visit
the directory, it is the Makefile in the subdirectory that
specifies what is modules and what is built-in.

It is good practice to use a CONFIG_ variable when assigning directory
names. This allows kbuild to totally skip the directory if the
corresponding CONFIG_ option is neither 'y' nor 'm'.

--- 3.7 Compilation flags

EXTRA_CFLAGS, EXTRA_AFLAGS, EXTRA_LDFLAGS, EXTRA_ARFLAGS

All the EXTRA_ variables apply only to the kbuild makefile
where they are assigned. The EXTRA_ variables apply to all
commands executed in the kbuild makefile.

$(EXTRA_CFLAGS) specifies options for compiling C files with
$(CC).

Example:
# drivers/sound/emu10k1/Makefile
EXTRA_CFLAGS += -I$(obj)
ifdef DEBUG
EXTRA_CFLAGS += -DEMU10K1_DEBUG
endif

This variable is necessary because the top Makefile owns the
variable $(CFLAGS) and uses it for compilation flags for the
entire tree.

$(EXTRA_AFLAGS) is a similar string for per-directory options
when compiling assembly language source.

Example:
#arch/x86_64/kernel/Makefile
EXTRA_AFLAGS := -traditional

$(EXTRA_LDFLAGS) and $(EXTRA_ARFLAGS) are similar strings for
per-directory options to $(LD) and $(AR).

Example:
#arch/m68k/fpsp040/Makefile
EXTRA_LDFLAGS := -x

CFLAGS_$@, AFLAGS_$@

CFLAGS_$@ and AFLAGS_$@ only apply to commands in current
kbuild makefile.

$(CFLAGS_$@) specifies per-file options for $(CC). The $@
part has a literal value which specifies the file that it is for.

Example:
# drivers/scsi/Makefile
CFLAGS_aha152x.o = -DAHA152X_STAT -DAUTOCONF
CFLAGS_gdth.o = # -DDEBUG_GDTH=2 -D__SERIAL__ -D__COM2__ \
-DGDTH_STATISTICS
CFLAGS_seagate.o = -DARBITRATE -DPARITY -DSEAGATE_USE_ASM

These three lines specify compilation flags for aha152x.o,
gdth.o, and seagate.o

$(AFLAGS_$@) is a similar feature for source files in assembly
languages.

Example:
# arch/arm/kernel/Makefile
AFLAGS_head-armv.o := -DTEXTADDR=$(TEXTADDR) -traditional
AFLAGS_head-armo.o := -DTEXTADDR=$(TEXTADDR) -traditional

--- 3.9 Dependency tracking

Kbuild tracks dependencies on the following:
1) All prerequisite files (both *.c and *.h)
2) CONFIG_ options used in all prerequisite files
3) Command-line used to compile target

Thus, if you change an option to $(CC) all affected files will
be re-compiled.

--- 3.10 Special Rules

Special rules are used when the kbuild infrastructure does
not provide the required support. A typical example is
header files generated during the build process.
Another example are the architecture specific Makefiles which
need special rules to prepare boot images etc.

Special rules are written as normal Make rules.
Kbuild is not executing in the directory where the Makefile is
located, so all special rules shall provide a relative
path to prerequisite files and target files.

Two variables are used when defining special rules:

$(src)
$(src) is a relative path which points to the directory
where the Makefile is located. Always use $(src) when
referring to files located in the src tree.

$(obj)
$(obj) is a relative path which points to the directory
where the target is saved. Always use $(obj) when
referring to generated files.

Example:
#drivers/scsi/Makefile
$(obj)/53c8xx_d.h: $(src)/53c7,8xx.scr $(src)/script_asm.pl
$(CPP) -DCHIP=810 - < $< | ... $(src)/script_asm.pl

This is a special rule, following the normal syntax
required by make.
The target file depends on two prerequisite files. References
to the target file are prefixed with $(obj), references
to prerequisites are referenced with $(src) (because they are not
generated files).

--- 3.11 $(CC) support functions

The kernel may be built with several different versions of
$(CC), each supporting a unique set of features and options.
kbuild provide basic support to check for valid options for $(CC).
$(CC) is usually the gcc compiler, but other alternatives are
available.

as-option
as-option is used to check if $(CC) -- when used to compile
assembler (*.S) files -- supports the given option. An optional
second option may be specified if the first option is not supported.

Example:
#arch/sh/Makefile
cflags-y += $(call as-option,-Wa$(comma)-isa=$(isa-y),)

In the above example, cflags-y will be assigned the option
-Wa$(comma)-isa=$(isa-y) if it is supported by $(CC).
The second argument is optional, and if supplied will be used
if first argument is not supported.

ld-option
ld-option is used to check if $(CC) when used to link object files
supports the given option. An optional second option may be
specified if first option are not supported.

Example:
#arch/i386/kernel/Makefile
vsyscall-flags += $(call ld-option, -Wl$(comma)--hash-style=sysv)

In the above example vsyscall-flags will be assigned the option
-Wl$(comma)--hash-style=sysv if it is supported by $(CC).
The second argument is optional, and if supplied will be used
if first argument is not supported.

as-instr
as-instr checks if the assembler reports a specific instruction
and then outputs either option1 or option2
C escapes are supported in the test instruction

cc-option
cc-option is used to check if $(CC) supports a given option, and not
supported to use an optional second option.

Example:
#arch/i386/Makefile
cflags-y += $(call cc-option,-march=pentium-mmx,-march=i586)

In the above example cflags-y will be assigned the option
-march=pentium-mmx if supported by $(CC), otherwise -march=i586.
The second argument to cc-option is optional, and if omitted,
cflags-y will be assigned no value if first option is not supported.

cc-option-yn
cc-option-yn is used to check if gcc supports a given option
and return 'y' if supported, otherwise 'n'.

Example:
#arch/ppc/Makefile
biarch := $(call cc-option-yn, -m32)
aflags-$(biarch) += -a32
cflags-$(biarch) += -m32

In the above example, $(biarch) is set to y if $(CC) supports the -m32
option. When $(biarch) equals 'y', the expanded variables $(aflags-y)
and $(cflags-y) will be assigned the values -a32 and -m32,
respectively.

cc-option-align
gcc versions >= 3.0 changed the type of options used to specify
alignment of functions, loops etc. $(cc-option-align), when used
as prefix to the align options, will select the right prefix:
gcc < 3.00
cc-option-align = -malign
gcc >= 3.00
cc-option-align = -falign

Example:
CFLAGS += $(cc-option-align)-functions=4

In the above example, the option -falign-functions=4 is used for
gcc >= 3.00. For gcc < 3.00, -malign-functions=4 is used.

cc-version
cc-version returns a numerical version of the $(CC) compiler version.
The format is where both are two digits. So for example
gcc 3.41 would return 0341.
cc-version is useful when a specific $(CC) version is faulty in one
area, for example -mregparm=3 was broken in some gcc versions
even though the option was accepted by gcc.

Example:
#arch/i386/Makefile
cflags-y += $(shell \
if [ $(call cc-version) -ge 0300 ] ; then \
echo "-mregparm=3"; fi ;)

In the above example, -mregparm=3 is only used for gcc version greater
than or equal to gcc 3.0.

cc-ifversion
cc-ifversion tests the version of $(CC) and equals last argument if
version expression is true.

Example:
#fs/reiserfs/Makefile
EXTRA_CFLAGS := $(call cc-ifversion, -lt, 0402, -O1)

In this example, EXTRA_CFLAGS will be assigned the value -O1 if the
$(CC) version is less than 4.2.
cc-ifversion takes all the shell operators:
-eq, -ne, -lt, -le, -gt, and -ge
The third parameter may be a text as in this example, but it may also
be an expanded variable or a macro.

=== 4 Host Program support

Kbuild supports building executables on the host for use during the
compilation stage.
Two steps are required in order to use a host executable.

The first step is to tell kbuild that a host program exists. This is
done utilising the variable hostprogs-y.

The second step is to add an explicit dependency to the executable.
This can be done in two ways. Either add the dependency in a rule,
or utilise the variable $(always).
Both possibilities are described in the following.

--- 4.1 Simple Host Program

In some cases there is a need to compile and run a program on the
computer where the build is running.
The following line tells kbuild that the program bin2hex shall be
built on the build host.

Example:
hostprogs-y := bin2hex

Kbuild assumes in the above example that bin2hex is made from a single
c-source file named bin2hex.c located in the same directory as
the Makefile.

--- 4.2 Composite Host Programs

Host programs can be made up based on composite objects.
The syntax used to define composite objects for host programs is
similar to the syntax used for kernel objects.
$(-objs) lists all objects used to link the final
executable.

Example:
#scripts/lxdialog/Makefile
hostprogs-y := lxdialog
lxdialog-objs := checklist.o lxdialog.o

Objects with extension .o are compiled from the corresponding .c
files. In the above example, checklist.c is compiled to checklist.o
and lxdialog.c is compiled to lxdialog.o.
Finally, the two .o files are linked to the executable, lxdialog.
Note: The syntax -y is not permitted for host-programs.

--- 4.3 Defining shared libraries

Objects with extension .so are considered shared libraries, and
will be compiled as position independent objects.
Kbuild provides support for shared libraries, but the usage
shall be restricted.
In the following example the libkconfig.so shared library is used
to link the executable conf.

Example:
#scripts/kconfig/Makefile
hostprogs-y := conf
conf-objs := conf.o libkconfig.so
libkconfig-objs := expr.o type.o

Shared libraries always require a corresponding -objs line, and
in the example above the shared library libkconfig is composed by
the two objects expr.o and type.o.
expr.o and type.o will be built as position independent code and
linked as a shared library libkconfig.so. C++ is not supported for
shared libraries.

--- 4.4 Using C++ for host programs

kbuild offers support for host programs written in C++. This was
introduced solely to support kconfig, and is not recommended
for general use.

Example:
#scripts/kconfig/Makefile
hostprogs-y := qconf
qconf-cxxobjs := qconf.o

In the example above the executable is composed of the C++ file
qconf.cc - identified by $(qconf-cxxobjs).

If qconf is composed by a mixture of .c and .cc files, then an
additional line can be used to identify this.

Example:
#scripts/kconfig/Makefile
hostprogs-y := qconf
qconf-cxxobjs := qconf.o
qconf-objs := check.o

--- 4.5 Controlling compiler options for host programs

When compiling host programs, it is possible to set specific flags.
The programs will always be compiled utilising $(HOSTCC) passed
the options specified in $(HOSTCFLAGS).
To set flags that will take effect for all host programs created
in that Makefile, use the variable HOST_EXTRACFLAGS.

Example:
#scripts/lxdialog/Makefile
HOST_EXTRACFLAGS += -I/usr/include/ncurses

To set specific flags for a single file the following construction
is used:

Example:
#arch/ppc64/boot/Makefile
HOSTCFLAGS_piggyback.o := -DKERNELBASE=$(KERNELBASE)

It is also possible to specify additional options to the linker.

Example:
#scripts/kconfig/Makefile
HOSTLOADLIBES_qconf := -L$(QTDIR)/lib

When linking qconf, it will be passed the extra option
"-L$(QTDIR)/lib".

--- 4.6 When host programs are actually built

Kbuild will only build host-programs when they are referenced
as a prerequisite.
This is possible in two ways:

(1) List the prerequisite explicitly in a special rule.

Example:
#drivers/pci/Makefile
hostprogs-y := gen-devlist
$(obj)/devlist.h: $(src)/pci.ids $(obj)/gen-devlist
( cd $(obj); ./gen-devlist ) < $<

The target $(obj)/devlist.h will not be built before
$(obj)/gen-devlist is updated. Note that references to
the host programs in special rules must be prefixed with $(obj).

(2) Use $(always)
When there is no suitable special rule, and the host program
shall be built when a makefile is entered, the $(always)
variable shall be used.

Example:
#scripts/lxdialog/Makefile
hostprogs-y := lxdialog
always := $(hostprogs-y)

This will tell kbuild to build lxdialog even if not referenced in
any rule.

--- 4.7 Using hostprogs-$(CONFIG_FOO)

A typical pattern in a Kbuild file looks like this:

Example:
#scripts/Makefile
hostprogs-$(CONFIG_KALLSYMS) += kallsyms

Kbuild knows about both 'y' for built-in and 'm' for module.
So if a config symbol evaluate to 'm', kbuild will still build
the binary. In other words, Kbuild handles hostprogs-m exactly
like hostprogs-y. But only hostprogs-y is recommended to be used
when no CONFIG symbols are involved.

=== 5 Kbuild clean infrastructure

"make clean" deletes most generated files in the obj tree where the kernel
is compiled. This includes generated files such as host programs.
Kbuild knows targets listed in $(hostprogs-y), $(hostprogs-m), $(always),
$(extra-y) and $(targets). They are all deleted during "make clean".
Files matching the patterns "*.[oas]", "*.ko", plus some additional files
generated by kbuild are deleted all over the kernel src tree when
"make clean" is executed.

Additional files can be specified in kbuild makefiles by use of $(clean-files).

Example:
#drivers/pci/Makefile
clean-files := devlist.h classlist.h

When executing "make clean", the two files "devlist.h classlist.h" will
be deleted. Kbuild will assume files to be in same relative directory as the
Makefile except if an absolute path is specified (path starting with '/').

To delete a directory hierarchy use:

Example:
#scripts/package/Makefile
clean-dirs := $(objtree)/debian/

This will delete the directory debian, including all subdirectories.
Kbuild will assume the directories to be in the same relative path as the
Makefile if no absolute path is specified (path does not start with '/').

Usually kbuild descends down in subdirectories due to "obj-* := dir/",
but in the architecture makefiles where the kbuild infrastructure
is not sufficient this sometimes needs to be explicit.

Example:
#arch/i386/boot/Makefile
subdir- := compressed/

The above assignment instructs kbuild to descend down in the
directory compressed/ when "make clean" is executed.

To support the clean infrastructure in the Makefiles that builds the
final bootimage there is an optional target named archclean:

Example:
#arch/i386/Makefile
archclean:
$(Q)$(MAKE) $(clean)=arch/i386/boot

When "make clean" is executed, make will descend down in arch/i386/boot,
and clean as usual. The Makefile located in arch/i386/boot/ may use
the subdir- trick to descend further down.

Note 1: arch/$(ARCH)/Makefile cannot use "subdir-", because that file is
included in the top level makefile, and the kbuild infrastructure
is not operational at that point.

Note 2: All directories listed in core-y, libs-y, drivers-y and net-y will
be visited during "make clean".

=== 6 Architecture Makefiles

The top level Makefile sets up the environment and does the preparation,
before starting to descend down in the individual directories.
The top level makefile contains the generic part, whereas
arch/$(ARCH)/Makefile contains what is required to set up kbuild
for said architecture.
To do so, arch/$(ARCH)/Makefile sets up a number of variables and defines
a few targets.

When kbuild executes, the following steps are followed (roughly):
1) Configuration of the kernel => produce .config
2) Store kernel version in include/linux/version.h
3) Symlink include/asm to include/asm-$(ARCH)
4) Updating all other prerequisites to the target prepare:
- Additional prerequisites are specified in arch/$(ARCH)/Makefile
5) Recursively descend down in all directories listed in
init-* core* drivers-* net-* libs-* and build all targets.
- The values of the above variables are expanded in arch/$(ARCH)/Makefile.
6) All object files are then linked and the resulting file vmlinux is
located at the root of the obj tree.
The very first objects linked are listed in head-y, assigned by
arch/$(ARCH)/Makefile.
7) Finally, the architecture specific part does any required post processing
and builds the final bootimage.
- This includes building boot records
- Preparing initrd images and thelike

--- 6.1 Set variables to tweak the build to the architecture

LDFLAGS Generic $(LD) options

Flags used for all invocations of the linker.
Often specifying the emulation is sufficient.

Example:
#arch/s390/Makefile
LDFLAGS := -m elf_s390
Note: EXTRA_LDFLAGS and LDFLAGS_$@ can be used to further customise
the flags used. See chapter 7.

LDFLAGS_MODULE Options for $(LD) when linking modules

LDFLAGS_MODULE is used to set specific flags for $(LD) when
linking the .ko files used for modules.
Default is "-r", for relocatable output.

LDFLAGS_vmlinux Options for $(LD) when linking vmlinux

LDFLAGS_vmlinux is used to specify additional flags to pass to
the linker when linking the final vmlinux image.
LDFLAGS_vmlinux uses the LDFLAGS_$@ support.

Example:
#arch/i386/Makefile
LDFLAGS_vmlinux := -e stext

OBJCOPYFLAGS objcopy flags

When $(call if_changed,objcopy) is used to translate a .o file,
the flags specified in OBJCOPYFLAGS will be used.
$(call if_changed,objcopy) is often used to generate raw binaries on
vmlinux.

Example:
#arch/s390/Makefile
OBJCOPYFLAGS := -O binary

#arch/s390/boot/Makefile
$(obj)/image: vmlinux FORCE
$(call if_changed,objcopy)

In this example, the binary $(obj)/image is a binary version of
vmlinux. The usage of $(call if_changed,xxx) will be described later.

AFLAGS $(AS) assembler flags

Default value - see top level Makefile
Append or modify as required per architecture.

Example:
#arch/sparc64/Makefile
AFLAGS += -m64 -mcpu=ultrasparc

CFLAGS $(CC) compiler flags

Default value - see top level Makefile
Append or modify as required per architecture.

Often, the CFLAGS variable depends on the configuration.

Example:
#arch/i386/Makefile
cflags-$(CONFIG_M386) += -march=i386
CFLAGS += $(cflags-y)

Many arch Makefiles dynamically run the target C compiler to
probe supported options:

#arch/i386/Makefile

...
cflags-$(CONFIG_MPENTIUMII) += $(call cc-option,\
-march=pentium2,-march=i686)
...
# Disable unit-at-a-time mode ...
CFLAGS += $(call cc-option,-fno-unit-at-a-time)
...

The first example utilises the trick that a config option expands
to 'y' when selected.

CFLAGS_KERNEL $(CC) options specific for built-in

$(CFLAGS_KERNEL) contains extra C compiler flags used to compile
resident kernel code.

CFLAGS_MODULE $(CC) options specific for modules

$(CFLAGS_MODULE) contains extra C compiler flags used to compile code
for loadable kernel modules.

--- 6.2 Add prerequisites to archprepare:

The archprepare: rule is used to list prerequisites that need to be
built before starting to descend down in the subdirectories.
This is usually used for header files containing assembler constants.

Example:
#arch/arm/Makefile
archprepare: maketools

In this example, the file target maketools will be processed
before descending down in the subdirectories.
See also chapter XXX-TODO that describe how kbuild supports
generating offset header files.

--- 6.3 List directories to visit when descending

An arch Makefile cooperates with the top Makefile to define variables
which specify how to build the vmlinux file. Note that there is no
corresponding arch-specific section for modules; the module-building
machinery is all architecture-independent.

head-y, init-y, core-y, libs-y, drivers-y, net-y

$(head-y) lists objects to be linked first in vmlinux.
$(libs-y) lists directories where a lib.a archive can be located.
The rest lists directories where a built-in.o object file can be
located.

$(init-y) objects will be located after $(head-y).
Then the rest follows in this order:
$(core-y), $(libs-y), $(drivers-y) and $(net-y).

The top level Makefile defines values for all generic directories,
and arch/$(ARCH)/Makefile only adds architecture specific directories.

Example:
#arch/sparc64/Makefile
core-y += arch/sparc64/kernel/
libs-y += arch/sparc64/prom/ arch/sparc64/lib/
drivers-$(CONFIG_OPROFILE) += arch/sparc64/oprofile/

--- 6.4 Architecture specific boot images

An arch Makefile specifies goals that take the vmlinux file, compress
it, wrap it in bootstrapping code, and copy the resulting files
somewhere. This includes various kinds of installation commands.
The actual goals are not standardized across architectures.

It is common to locate any additional processing in a boot/
directory below arch/$(ARCH)/.

Kbuild does not provide any smart way to support building a
target specified in boot/. Therefore arch/$(ARCH)/Makefile shall
call make manually to build a target in boot/.

The recommended approach is to include shortcuts in
arch/$(ARCH)/Makefile, and use the full path when calling down
into the arch/$(ARCH)/boot/Makefile.

Example:
#arch/i386/Makefile
boot := arch/i386/boot
bzImage: vmlinux
$(Q)$(MAKE) $(build)=$(boot) $(boot)/$@

"$(Q)$(MAKE) $(build)=" is the recommended way to invoke
make in a subdirectory.

There are no rules for naming architecture specific targets,
but executing "make help" will list all relevant targets.
To support this, $(archhelp) must be defined.

Example:
#arch/i386/Makefile
define archhelp
echo '* bzImage - Image (arch/$(ARCH)/boot/bzImage)'
endif

When make is executed without arguments, the first goal encountered
will be built. In the top level Makefile the first goal present
is all:.
An architecture shall always, per default, build a bootable image.
In "make help", the default goal is highlighted with a '*'.
Add a new prerequisite to all: to select a default goal different
from vmlinux.

Example:
#arch/i386/Makefile
all: bzImage

When "make" is executed without arguments, bzImage will be built.

--- 6.5 Building non-kbuild targets

extra-y

extra-y specify additional targets created in the current
directory, in addition to any targets specified by obj-*.

Listing all targets in extra-y is required for two purposes:
1) Enable kbuild to check changes in command lines
- When $(call if_changed,xxx) is used
2) kbuild knows what files to delete during "make clean"

Example:
#arch/i386/kernel/Makefile
extra-y := head.o init_task.o

In this example, extra-y is used to list object files that
shall be built, but shall not be linked as part of built-in.o.

--- 6.6 Commands useful for building a boot image

Kbuild provides a few macros that are useful when building a
boot image.

if_changed

if_changed is the infrastructure used for the following commands.

Usage:
target: source(s) FORCE
$(call if_changed,ld/objcopy/gzip)

When the rule is evaluated, it is checked to see if any files
needs an update, or the command line has changed since the last
invocation. The latter will force a rebuild if any options
to the executable have changed.
Any target that utilises if_changed must be listed in $(targets),
otherwise the command line check will fail, and the target will
always be built.
Assignments to $(targets) are without $(obj)/ prefix.
if_changed may be used in conjunction with custom commands as
defined in 6.7 "Custom kbuild commands".

Note: It is a typical mistake to forget the FORCE prerequisite.
Another common pitfall is that whitespace is sometimes
significant; for instance, the below will fail (note the extra space
after the comma):
target: source(s) FORCE
#WRONG!# $(call if_changed, ld/objcopy/gzip)

ld
Link target. Often, LDFLAGS_$@ is used to set specific options to ld.

objcopy
Copy binary. Uses OBJCOPYFLAGS usually specified in
arch/$(ARCH)/Makefile.
OBJCOPYFLAGS_$@ may be used to set additional options.

gzip
Compress target. Use maximum compression to compress target.

Example:
#arch/i386/boot/Makefile
LDFLAGS_bootsect := -Ttext 0x0 -s --oformat binary
LDFLAGS_setup := -Ttext 0x0 -s --oformat binary -e begtext

targets += setup setup.o bootsect bootsect.o
$(obj)/setup $(obj)/bootsect: %: %.o FORCE
$(call if_changed,ld)

In this example, there are two possible targets, requiring different
options to the linker. The linker options are specified using the
LDFLAGS_$@ syntax - one for each potential target.
$(targets) are assigned all potential targets, by which kbuild knows
the targets and will:
1) check for commandline changes
2) delete target during make clean

The ": %: %.o" part of the prerequisite is a shorthand that
free us from listing the setup.o and bootsect.o files.
Note: It is a common mistake to forget the "target :=" assignment,
resulting in the target file being recompiled for no
obvious reason.

--- 6.7 Custom kbuild commands

When kbuild is executing with KBUILD_VERBOSE=0, then only a shorthand
of a command is normally displayed.
To enable this behaviour for custom commands kbuild requires
two variables to be set:
quiet_cmd_ - what shall be echoed
cmd_ - the command to execute

Example:
#
quiet_cmd_image = BUILD $@
cmd_image = $(obj)/tools/build $(BUILDFLAGS) \
$(obj)/vmlinux.bin > $@

targets += bzImage
$(obj)/bzImage: $(obj)/vmlinux.bin $(obj)/tools/build FORCE
$(call if_changed,image)
@echo 'Kernel: $@ is ready'

When updating the $(obj)/bzImage target, the line

BUILD arch/i386/boot/bzImage

will be displayed with "make KBUILD_VERBOSE=0".

--- 6.8 Preprocessing linker scripts

When the vmlinux image is built, the linker script
arch/$(ARCH)/kernel/vmlinux.lds is used.
The script is a preprocessed variant of the file vmlinux.lds.S
located in the same directory.
kbuild knows .lds files and includes a rule *lds.S -> *lds.

Example:
#arch/i386/kernel/Makefile
always := vmlinux.lds

#Makefile
export CPPFLAGS_vmlinux.lds += -P -C -U$(ARCH)

The assignment to $(always) is used to tell kbuild to build the
target vmlinux.lds.
The assignment to $(CPPFLAGS_vmlinux.lds) tells kbuild to use the
specified options when building the target vmlinux.lds.

When building the *.lds target, kbuild uses the variables:
CPPFLAGS : Set in top-level Makefile
EXTRA_CPPFLAGS : May be set in the kbuild makefile
CPPFLAGS_$(@F) : Target specific flags.
Note that the full filename is used in this
assignment.

The kbuild infrastructure for *lds file are used in several
architecture specific files.

=== 7 Kbuild Variables

The top Makefile exports the following variables:

VERSION, PATCHLEVEL, SUBLEVEL, EXTRAVERSION

These variables define the current kernel version. A few arch
Makefiles actually use these values directly; they should use
$(KERNELRELEASE) instead.

$(VERSION), $(PATCHLEVEL), and $(SUBLEVEL) define the basic
three-part version number, such as "2", "4", and "0". These three
values are always numeric.

$(EXTRAVERSION) defines an even tinier sublevel for pre-patches
or additional patches. It is usually some non-numeric string
such as "-pre4", and is often blank.

KERNELRELEASE

$(KERNELRELEASE) is a single string such as "2.4.0-pre4", suitable
for constructing installation directory names or showing in
version strings. Some arch Makefiles use it for this purpose.

ARCH

This variable defines the target architecture, such as "i386",
"arm", or "sparc". Some kbuild Makefiles test $(ARCH) to
determine which files to compile.

By default, the top Makefile sets $(ARCH) to be the same as the
host system architecture. For a cross build, a user may
override the value of $(ARCH) on the command line:

make ARCH=m68k ...

INSTALL_PATH

This variable defines a place for the arch Makefiles to install
the resident kernel image and System.map file.
Use this for architecture specific install targets.

INSTALL_MOD_PATH, MODLIB

$(INSTALL_MOD_PATH) specifies a prefix to $(MODLIB) for module
installation. This variable is not defined in the Makefile but
may be passed in by the user if desired.

$(MODLIB) specifies the directory for module installation.
The top Makefile defines $(MODLIB) to
$(INSTALL_MOD_PATH)/lib/modules/$(KERNELRELEASE). The user may
override this value on the command line if desired.

INSTALL_MOD_STRIP

If this variable is specified, will cause modules to be stripped
after they are installed. If INSTALL_MOD_STRIP is '1', then the
default option --strip-debug will be used. Otherwise,
INSTALL_MOD_STRIP will used as the option(s) to the strip command.

=== 8 Makefile language

The kernel Makefiles are designed to be run with GNU Make. The Makefiles
use only the documented features of GNU Make, but they do use many
GNU extensions.

GNU Make supports elementary list-processing functions. The kernel
Makefiles use a novel style of list building and manipulation with few
"if" statements.

GNU Make has two assignment operators, ":=" and "=". ":=" performs
immediate evaluation of the right-hand side and stores an actual string
into the left-hand side. "=" is like a formula definition; it stores the
right-hand side in an unevaluated form and then evaluates this form each
time the left-hand side is used.

There are some cases where "=" is appropriate. Usually, though, ":="
is the right choice.

=== 9 Credits

Original version made by Michael Elizabeth Chastain,
Updates by Kai Germaschewski
Updates by Sam Ravnborg
Language QA by Jan Engelhardt

=== 10 TODO

- Describe how kbuild supports shipped files with _shipped.
- Generating offset header files.
- Add more variables to section 7?

Ref: kernel Documentation/kbuild/makefiles.txt

What is the difference between tty & ttyS

2009-02-09T12:54:00.001+05:30

/dev/tty ar the loginshells on your computer (/dev/tty1-6 representing alt+F1-6)
/dev/ttyS0-n on the other hand are the seriel ports on you computer (Typically known as com 1-4 on a windows machine)

Ref:
http://www.linuxquestions.org/questions/linux-hardware-18/difference-between-tty-and-ttys-605986/

IP Networking Control Files

2008-11-26T13:49:00.002+05:30

Different linux distribution vendors put their networking configuration files in different places in the filesystem. Here is a brief summary of the locations of the IP networking configuration information under a few common linux distributions along with links to further documentation.

Location of networking configuration files

RedHat (and Mandrake)
- Interface definitions /etc/sysconfig/network-scripts/ifcfg-*
- Hostname and default gateway definition /etc/sysconfig/network
- Definition of static routes /etc/sysconfig/static-routes
SuSe (version >= 8.0)
- Interface definitions /etc/sysconfig/network/ifcfg-*
- Static route definition /etc/sysconfig/network/routes
- Interface specific static route definition /etc/sysconfig/network/ifroute-*
SuSe (version <= 8.0)
- Interface and route definitions /etc/rc.config
Debian
- Interface and route definitions /etc/network/interfaces
Gentoo
- Interface and route definitions /etc/conf.d/net
Slackware
- Interface and route definitions /etc/rc.d/rc.inet1

The format of the networking configuration files differs significantly from distribution to distribution, yet the tools used by these scripts are the same. This documentation will focus on these tools and how they instruct the kernel to alter interface and route information. Consult the distribution's documentation for questions of file format and order of operation.

Ref: http://linux-ip.net/html/basic-control-files.html

Command Hacks

2008-11-25T12:10:00.024+05:30

man 4 console_codes

mount -t ntfs-3g /dev/sda6 /mnt/ -o force

Set the file system to particular partition
$mkfs.ext2 /dev/hda8
$mkfs.ext3 /dev/hda8
$tune2fs -j /dev/hda8 ---> ext2 to ext3
$blkid ----> you can use it to check the filetype of block device

How to create a partition from command line
$fdisk /dev/hda
>command(m for help): n
n for add new partition
>commandaction
>e extended
>p primary partition (1-4)
:p
>partition number(1-4):3
we are creating hda3
>First Cylender(1341-2438, default 1341):
to chose default just press Enter key
>Last cylinder or +size or +sizeM or +sizeK(1341-2438, default 2438): +56B
size is 56B
>p
> t
change a partition`s system id
>partition no(1-4):3
>Hexcode(type L to list codes): L
shows list
>hexcode(type L to list codes): 83

How to set IP address, Subnet mask , and gateway

The ip address can be assigned using ifconfig command
ifconfig "interface type" "ip address" "subnet mask" "broadcast address"
Ex:
ifconfig hme0 10.192.10.18 netmask 255.255.255.0 broadcast 10.192.10.255
ifconfig hme0 up

and the default gateway can be assigned in the /etc/defaultrouter file:

vi defaultrouter
10.192.10.1
:wq!

2) reset bootprom " " (just confirm using boot ? at OK prompt and to
come toOK prompt do init0)

Ref: http://unix.ittoolbox.com/groups/technical-functional/solaris-l/how-to-set-ip-address-subnet-mask-and-gateway-464377

Passwordless ssh login

1) Suppose you are login on 192.168.1.109
Type the following command to generate key
$ ssh-keygen -t dsa
Generating public/private dsa key pair.
Enter file in which to save the key (/root/.ssh/id_dsa): /root/.ssh/id_dsa
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_dsa.
Your public key has been saved in /root/.ssh/id_dsa.pub.
The key fingerprint is:
9f:7c:6c:a4:98:a7:25:03:cd:3c:4d:57:0e:c8:db:47 root@localhost.localdomain

2) Now copy this key to any computer.
$ssh-copy-id -i /root/.ssh/id_dsa root@192.168.1.31
root@192.168.1.31's password:
Now try logging into the machine, with "ssh 'root@192.168.1.31'", and check in:

.ssh/authorized_keys

to make sure we haven't added extra keys that you weren't expecting.

Ref: http://www.linuxjournal.com/video/ssh-logins-without-passwords

Displays information about ELF files.

$readelf --segments /bin/ls
$readelf --segments /lib/libc.so.6
$readelf -a /bin/ls
--------------------------------------------------------------------------------------------------
find command
---------------------------------------------------------------------------------------------------
Sed -----------

Printing File Lines using Address and Patterns
Delete File Lines Using Address and PatternsFind and Replace Text Inside a File Using RegEx
How To Write to a File Using Sed
Append, Insert, Replace, and Count File Lines
How To Execute Multiple Sed Commands
Multi-Line File Operation
Examples for Sed Hold and Pattern Buffer Operations

Ref: www.thegeekstuff.com
---------------------------------------------------------------------------------------------------

Q. How to display a list of all manual pages containing the keyword "date", what command would you type?
Ans: man -k date or apropos date

Linux System Calls Details

2008-08-21T12:41:00.002+05:30

Linux System Calls Details

No	Function Name	Description	Source
1	exit	terminate the current process	kernel/exit.c
2	fork	create a child process	arch/i386/kernel/process.c
3	read	read from a file descriptor	fs/read_write.c
4	write	write to a file descriptor	fs/read_write.c
5	open	open a file or device	fs/open.c
6	close	close a file descriptor	fs/open.c
7	waitpid	wait for process termination	kernel/exit.c
8	creat	create a file or device	fs/open.c
9	link	make a new name for a file	fs/namei.c
10	unlink	delete a name and possibly the file it refers to	fs/namei.c
11	execve	execute program	arch/i386/kernel/process.c
12	chdir	change working directory	fs/open.c
13	time	get time in seconds	kernel/time.c
14	mknod	create a special or ordinary file	fs/namei.c
15	chmod	change permissions of a file	fs/open.c
16	lchown	change ownership of a file	fs/open.c
18	stat	get file status	fs/stat.c
19	lseek	reposition read/write file offset	fs/read_write.c
20	getpid	get process identification	kernel/sched.c
21	mount	mount filesystems	fs/super.c
22	umount	unmount filesystems	fs/super.c
23	setuid	set real user ID	kernel/sys.c
24	getuid	get real user ID	kernel/sched.c
25	stime	set system time and date	kernel/time.c
26	ptrace	allows a parent process to control the execution of a child process	arch/i386/kernel/ptrace.c
27	alarm	set an alarm clock for delivery of a signal	kernel/sched.c
28	fstat	get file status	fs/stat.c
29	pause	suspend process until signal	arch/i386/kernel/sys_i386.c
30	utime	set file access and modification times	fs/open.c
33	access	check user's permissions for a file	fs/open.c
34	nice	change process priority	kernel/sched.c

36	sync	update the super block	fs/buffer.c
37	kill	send signal to a process	kernel/signal.c
38	rename	change the name or location of a file	fs/namei.c
39	mkdir	create a directory	fs/namei.c
40	rmdir	remove a directory	fs/namei.c
41	dup	duplicate an open file descriptor	fs/fcntl.c
42	pipe	create an interprocess channel	arch/i386/kernel/sys_i386.c
43	times	get process times	kernel/sys.c
45	brk	change the amount of space allocated for the calling process's data segment	mm/mmap.c`
46	setgid	set real group ID	kernel/sys.c
47	getgid	get real group ID	kernel/sched.c
48	sys_signal	ANSI C signal handling	kernel/signal.c
49	geteuid	get effective user ID	kernel/sched.c
50	getegid	get effective group ID	kernel/sched.c
51	acct	enable or disable process accounting	kernel/acct.c
52	umount2	unmount a file system	fs/super.c
54	ioctl	control device	fs/ioctl.c
55	fcntl	file control	fs/fcntl.c
56	mpx	(unimplemented)
57	setpgid	set process group ID	kernel/sys.c
58	ulimit	(unimplemented)
59	olduname	obsolete uname system call	arch/i386/kernel/sys_i386.c
60	umask	set file creation mask	kernel/sys.c
61	chroot	change root directory	fs/open.c
62	ustat	get file system statistics	fs/super.c
63	dup2	duplicate a file descriptor	fs/fcntl.c
64	getppid	get parent process ID	kernel/sched.c
65	getpgrp	get the process group ID	kernel/sys.c
66	setsid	creates a session and sets the process group ID	kernel/sys.c
67	sigaction	POSIX signal handling functions	arch/i386/kernel/signal.c
68	sgetmask	ANSI C signal handling	kernel/signal.c

69	ssetmask	ANSI C signal handling	kernel/signal.c
70	setreuid	set real and effective user IDs	kernel/sys.c
71	setregid	set real and effective group IDs	kernel/sys.c
72	sigsuspend	install a signal mask and suspend caller until signal	arch/i386/kernel/signal.c
73	sigpending	examine signals that are blocked and pending	kernel/signal.c
74	sethostname	set hostname	kernel/sys.c
75	setrlimit	set maximum system resource con sumption	kernel/sys.c
76	getrlimit	get maximum system resource con sumption	kernel/sys.c
77	getrusage	get maximum system resource con sumption	kernel/sys.c
78	gettimeofday	get the date and time	kernel/time.c
79	settimeofday	set the date and time	kernel/time.c
80	getgroups	get list of supplementary group IDs	kernel/sys.c
81	setgroups	set list of supplementary group IDs	kernel/sys.c
82	old_select	sync. I/O multiplexing	arch/i386/kernel/sys_i386.c
83	symlink	make a symbolic link to a file	fs/namei.c
84	lstat	get file status	fs/stat.c
85	readlink	read the contents of a symbolic link	fs/stat.c
86	uselib	select shared library	fs/exec.c
87	swapon	start swapping to file/device	mm/swapfile.c
88	reboot	reboot or enable/disable Ctrl-Alt-Del	kernel/sys.c
89	old_readdir	read directory entry	fs/readdir.c
90	old_mmap	map pages of memory	arch/i386/kernel/sys_i386.c
91	munmap	unmap pages of memory	mm/mmap.c
92	truncate	set a file to a specified length	fs/open.c
93	ftruncate	set a file to a specified length	fs/open.c
94	fchmod	change access permission mode of file	fs/open.c
95	fchown	change owner and group of a file	fs/open.c
96	getpriority	get program scheduling priority	kernel/sys.c
97	setpriority	set program scheduling priority	kernel/sys.c

98	profil	execution time profile
99	statfs	get file system statistics	fs/open.c
100	fstatfs	get file system statistics	fs/open.c
101	ioperm	set port input/output permissions	arch/i386/kernel/ioport.c
102	socketcall	socket system calls	net/socket.c
103	syslog	read and/or clear kernel message ring buffer	kernel/printk.c
104	setitimer	set value of interval timer	kernel/itimer.c
105	getitimer	get value of interval timer	kernel/itimer.c
106	sys_newstat	get file status	fs/stat.c
107	sys_newlstat	get file status	fs/stat.c
108	sys_newfstat	get file status	fs/stat.c
109	olduname	get name and information about current kernel	arch/i386/kernel/sys_i386.c
110	iopl	change I/O privilege level	arch/i386/kernel/ioport.c
111	vhangup	virtually hangup the current tty	fs/open.c
112	idle	make process 0 idle	arch/i386/kernel/process.c
113	vm86old	enter virtual 8086 mode	arch/i386/kernel/vm86.c
114	wait4	wait for process termination, BSD style	kernel/exit.c
115	swapoff	stop swapping to file/device	mm/swapfile.c
116	sysinfo	returns information on overall system statistics	kernel/info.c
117	ipc	System V IPC system calls	arch/i386/kernel/sys_i386.c
118	fsync	synchronize a file's complete in-core state with that on disk	fs/buffer.c
119	sigreturn	return from signal handler and cleanup stack frame	arch/i386/kernel/signal.c
120	clone	create a child process	arch/i386/kernel/process.c
121	setdomain-name	set domain name	kernel/sys.c
122	uname	get name and information about current kernel	kernel/sys.c
123	modify_ldt	get or set ldt	arch/i386/kernel/ldt.c
124	adjtimex	tune kernel clock	kernel/time.c
125	mprotect	set protection of memory mapping	mm/mprotect.c

126	sigprocmask	POSIX signal handling functions	kernel/signal.c
127	create_module	create a loadable module entry	kernel/module.c
128	init_module	initialize a loadable module entry	kernel/module.c
129	delete_module	delete a loadable module entry	kernel/module.c
130	get_kernel_syms	retrieve exported kernel and module symbols	kernel/module.c
31	quotactl	manipulate disk quotas	fs/dquot.c
132	getpgid	get process group ID	kernel/sys.c
133	fchdir	change working directory	fs/open.c
134	bdflush	start, flush, or tune buffer-dirty-flush daemon	fs/buffer.c
135	sysfs	get file system type information	fs/super.c
136	personality	set the process execution domain	kernel/exec_domain.c
137	afs_syscall	(unimplemented)
138	setfsuid	set user identity used for file system checks	kernel/sys.c
139	setfsgid	set group identity used for file system checks	kernel/sys.c
140	sys_llseek	move extended read/write file pointer	fs/read_write.c
141	getdents	read directory entries	fs/readdir.c
142	select	sync. I/O multiplexing	fs/select.c
143	flock	apply or remove an advisory lock on an open file	fs/locks.c
144	msync	synchronize a file with a memory map	mm/filemap.c
145	readv	read data into multiple buffers	fs/read_write.c
146	writev	write data into multiple buffers	fs/read_write.c
147	sys_getsid	get process group ID of session leader	kernel/sys.c
148	fdatasync	synchronize a file's in-core data with that on disk	fs/buffer.c
149	sysctl	read/write system parameters	kernel/sysctl.c
150	mlock	lock pages in memory	mm/mlock.c
151	munlock	unlock pages in memory	mm/mlock.c

152	mlockall	disable paging for calling process	mm/mlock.c
153	munlockall	reenable paging for calling process	mm/mlock.c
154	sched_set-param	set scheduling parameters	kernel/sched.c
155	sched_get-param	get scheduling parameters	kernel/sched.c
156	sched_set-scheduler	set scheduling algorithm parameters	kernel/sched.c
157	sched_get-scheduler	get scheduling algorithm parameters	kernel/sched.c
158	sched_yield	yield the processor	kernel/sched.c
159	sched_get_p-riority_max	get max static priority range	kernel/sched.c
160	sched_get_p-riority_min	get min static priority range	kernel/sched.c
161	sched_rr_get_inter-val	get the SCHED_RR interval for the named process	kernel/sched.c
162	nanosleep	pause execution for a specified time (nano seconds)	kernel/sched.c
163	mremap	re-map a virtual memory address	mm/mremap.c
164	setresuid	set real, effective and saved user or group ID	kernel/sys.c
165	getresuid	get real, effective and saved user or group ID	kernel/sys.c
166	vm86	enter virtual 8086 mode	arch/i386/kernel/vm86.c
167	query_module	query the kernel for various bits pertain ing to modules	kernel/module.c
168	poll	wait for some event on a file descriptor	fs/select.c
169	nfsservctl	syscall interface to kernel nfs daemon	fs/filesystems.c
170	setresgid	set real, effective and saved user or group ID	kernel/sys.c
171	getresgid	get real, effective and saved user or group ID	kernel/sys.c
172	prctl	operations on a process	kernel/sys.c
173	rt_sigreturn		arch/i386/kernel/signal.c
174	rt_sigaction		kernel/signal.c

175	rt_sigprocmask		kernel/signal.c
176	rt_sigpending		kernel/signal.c
177	rt_sigtimedwait		kernel/signal.c
178	rt_sigqueueinfo		kernel/signal.c
179	rt_sigsuspend		arch/i386/kernel/signal.c
180	pread	read from a file descriptor at a given offset	fs/read_write.c
181	sys_pwrite	write to a file descriptor at a given offset	fs/read_write.c
182	chown	change ownership of a file	fs/open.c
183	getcwd	Get current working directory	fs/dcache.c
184	capget	get process capabilities	kernel/capability.c
185	capset	set process capabilities	kernel/capability.c
186	sigaltstack	set/get signal stack context	arch/i386/kernel/signal.c
187	sendfile	transfer data between file descriptors	mm/filemap.c
188	getpmsg	(unimplemented)
189	putpmsg	(unimplemented)
190	vfork	create a child process and block parent	arch/i386/kernel/process.c

Control Keys

2008-08-13T18:43:00.003+05:30

Control keys-those that you type by holding down the CONTROL (or CTRL) key and hitting another key-are another
type of special character. These normally don't print anything on your screen, but the operating system interprets a few
of them as special commands. You already know one of them: RETURN is actually the same as [CTRL-M] (try it and
see). You have probably also used the BACKSPACE or DEL key to erase typos on your command line.
Perhaps the most difficult thing about control keys is that they can differ from system to system. The usual arrangement
is shown in Table which lists the control keys that all major modern versions of UNIX support. Note that [CTRL-\] and [CTRL-|] (control-backslash and control-pipe) are the same character notated two different ways; the same is true of DEL and [CTRL-?].
You can use the stty command to find out what your settings are and change them if you wish;
If the version of UNIX on your system is one of those that derive from BSD (such as SunOS and Ultrix), type stty --all or stty -a to see your control-key settings; you will see something like this:
erase kill werase rprnt flush lnext susp intr quit stop eof
^? ^U ^W ^R ^O ^V ^Z/^Y ^C ^| ^S/^Q ^D

Control Key stty Name Function Description
CTRL-C intr Stop current command
CTRL-D eof End of input
[CTRL-\] or [CTRL-|] quit Stop current command, if [CTRL-C] doesn't work
CTRL-S stop Halt output to screen
CTRL-Q Restart output to screen
DEL or [CTRL-?] erase Erase last character
CTRL-U kill Erase entire command line
CTRL-Z susp Suspend current command

The ^X notation stands for CTRL-X. If your UNIX version derives from System III or System V (this includes AIX,
HP/UX, SCO, and Xenix), type stty -a; the resulting output will include this information:
intr = ^c; quit = ^|; erase = DEL; kill = ^u; eof = ^d; eol = ^`; swtch = ^`
susp = ^z; dsusp ;

The control key you will probably use most often is [CTRL-C], sometimes called the interrupt key. This stops-or tries to stop-the command that is currently running. You will want to use this when you enter a command and find that it's taking too long, you gave it the wrong arguments by mistake, you change your mind about wanting to run it, or whatever.

Sometimes [CTRL-C] doesn't work; in that case, if you really want to stop a job, try [CTRL-\]. But don't just type CTRL-\; always try [CTRL-C] first! Chapter 8 explains why in detail. For now, suffice it to say that [CTRL-C] gives the running job more of a chance to clean up before exiting, so that files and other resources are not left in funny states.

We've already seen an example of [CTRL-D]. When you are running a command that accepts standard input from your keyboard, [CTRL-D] tells the process that your input is finished-as if the process were reading a file and it reached the end of the file. mail is a utility in which this happens often. When you are typing in a message, you end by typing [CTRL-D]. This tells mail that your message is complete and ready to be sent. Most utilities that accept standard input
understand [CTRL-D] as the end-of-input character, though many such programs accept commands like q, quit, exit, etc. The shell itself understands [CTRL-D] as the end-of-input character: as we saw earlier in this chapter, you can normally end a login session by typing [CTRL-D] at the shell prompt. You are just telling the shell that its command input is finished.

CTRL-S and [CTRL-Q] are called flow-control characters. They represent an antiquated way of stopping and restarting the flow of output from one device to another (e.g., from the computer to your terminal) that was useful when the speed of such output was low. They are rather obsolete in these days of high-speed local networks and dialup lines. In fact, under the latter conditions, CTRL-S and [CTRL-Q] are basically a nuisance. The only thing you really need to know
about them is that if your screen output becomes "stuck," then you may have hit [CTRL-S] by accident. Type [CTRL-Q] to restart the output; any keys you may have hit in between will then take effect.

The final group of control characters gives you rudimentary ways to edit your command line. DEL acts as a backspace key (in fact, some systems use the actual BACKSPACE or [CTRL-H] key as "erase" instead of DEL); [CTRL-U] erases the entire line and lets you start over. Again, these are outmoded. [13] Instead of using these, go to the next chapter and read about Korn shell's editing modes, which are among its most exciting features.
[13] Why are so many outmoded control keys still in use? They have nothing to do with the shell per se; instead, they are recognized by the tty driver, an old and hoary part of the operating system's lower depths that controls input and output to/from your terminal.

env command

2008-08-13T11:21:00.002+05:30

Environment Variable	Description
`BASH`	Path of the BASH executable file
`BASH_ENV`	Path of the BASH environment file, which specifies BASH options
`BASH_VERSION`	Version of BASH
`COLUMNS`	Width, in characters, of console window
`EUID`	Effective user ID
`HISTFILE`	Path of the BASH command history file
`HISTFILESIZE`	Maximum number of lines recorded in history file
`HISTSIZE`	Maximum number of commands recorded in history file
`HOME`	Path of user’s home directory
`HOSTNAME`	Name of the host
`IFS`	Field separator (white space) characters
`LINES`	Length, in lines, of console window
`LOGNAME`	User’s log in name
`LS_COLORS`	Options for `ls` command
`OSTYPE`	Operating system name (”Linux”)
`PATH`	Program path
`PPID`	Process ID of the shell’s parent process
`PS1`	Command prompt string
`PS2`	Continuation prompt string
`PS4`	Execution trace string
`PWD`	Current working directory
`SHELL`	Path of the shell executable
`SHLVL`	Number of nested shell invocations
`TERM`	Terminal type
`UID`	User ID
`USER`	User name

Ref:http://www.linux-mag.com/id/803
http://linux.about.com/od/ttl_howto/a/hwtttl16t06.htm

Linux History

2008-05-20T16:42:00.014+05:30

Take some serious time to read through and understand the history lecture, it has been structured to give you a fuller understanding of the roots of the Unix and Linux operating systems.

Unix has managed to influence every operating system available today.

It seems that most of the people who want to work in, or who actually work in Linux do not know the history of the operating system and as you will see, it will give you

a greater understanding of the software.

In short, Linux is an operating system based on UNIX (Developed by AT&T's Bell Labs division), which is based on MULTICS.

The following timeline will explain the main events that have affected the UNIX family of operating systems, of which Linux is one.

We pick up our history in the 1950s, when the first important event that affected UNIX took place.

Figure 1.1. PDP 7 with teletypewriter

Note

TTYs and Line-oriented Text Display which was the general input and output devices of the PDP 7

The term "tty" stands for "teletypewriter", which was an early form of terminal.

Teletypewriters, such as the one shown in the picture of the PDP-7 REF, were merely automatic typewriters producing hard-copy line-based output on continuous paper.

In these early days of computing, this kind of terminal output did not allow screen or cursor-based programs to function.

Hence the first text editors were "line-oriented", such as "ed" and later "ex". "Vi" was developed later, based on "ex", and was screen-oriented. It used the redrawable ability of cathode ray tube (CRT) displays to show text one screen at a time.

1955

The US government passed a decree imposing a restraint of trade against AT&T. The company was not permitted to make money from non-telecommunications business.

This is significant, because until 1982 (when the US Government finally broke up the AT&T telecommunications monopoly into smaller companies), AT&T could not sell operating systems, i.e. UNIX, for profit.

This had a great impact on the distribution of Unix as you will see throughout the rest of the History section, as AT&T chose to use the product internally first, and then distributed it to computer research institutions such as Universities.

1966

The Multiplexed Time Sharing and Computing System or MULTICS project was a joint attempt by General Electric (GE), AT&T Bell Labs and the Massachusetts Institute of Technology (MIT) at developing a stable multiuser operating system

The aim is to create an operating system that could support a lot of simultaneous users (thousands!).

Multics stands for Multiplexed Information and Computer service.

The people involved in the project at this time are Ken Thompson, Dennis Ritchie, Joseph Ossanna, Stuart Feldman, Doug McIIroy and Bob Morris.

Although a very simple version of MULTICS could now run on a GE645 computer, it could only support 3 people and therefore the original goals of this operating system had not been met, the research and development is just so expensive and Bell Labs withdraws their sponsorship. This meant that the other interested parties could not afford to carry the project on their own and so they also withdrew.

Dennis Ritchie and Ken Thompson now decide to continue this project on their own.

1969 to 1970

Ken Thompson Dennis Ritchie wrote a Space Travel Game that was actually a serious scientific astronomical simulation program. However the game was a disaster as the spaceship was hard to maneuver and used a lot of resources to run.

After developing the Space Travel Program they had learnt a lot more. With Canaday involved as well they were able to create the design for a new file system, which they built on PDP-7, called UNICS (Uniplexed Information and Computing Service), and this later became UNIX.

A note to UNIX traditionalists: We use the spelling "Unix" rather than "UNIX" in this course only for the sake of readability.

They attempted using a Fortran program to further develop Unix, but they found that it was not what they were looking for and so they turned to BCPL (Basic Combined Programming Language).

B was developed from BCPL and it was the first high-level language to be used on Unix with a PDP11/20.

Assembler/ compilers / hardware architecture

Lets draw a diagram of three different machines and then lets take a look at why developing in assembler is not always the best idea:

Remember that all a computer actually does is mathematics.
Am operating system is a "resource allocator" and a "controlling of operations" program.
When computers first started becoming popular we had to use punch cards or load the programs directly into memory manually.
Assembler is machine code and is specific to the machine type and hardware that you are working with. The instruction written for one machine cannot work for another machine at this low level.
A computer has registers and instruction sets, and the instructions are binary coded, the assembly program talks to the machine in assembler which is translated to binary code.

Figure 1.2. Relationship between hardware, assembler and a compiler

So, if writing a program for a PDP-7 and using assembler, when wanting to move the program to a PDP-11 you would have to rewrite the entire assembler program, this time to suit the machine and hardware type for a PDP-11.

To remedy this, developers invented compilers for application programming tools. In other words if using Pascal to develop, the Pascal compiler for a PDP-7 would translate your program into assembly program and then assembler code for a PDP-7.

If wanting to port that program to a PDP-11, then get the Pascal compiler for a PDP-11 and recompile the original program on the PDP-11. It will then work as above.

This explains why the higher-level languages started being used, such as Pascal, Fortran etcetera. They are there to provide libraries between program and assembler. A compiler would be needed for each specific machine.

These days a compiler automatically generates the assembler code.

Figure 1.3. Dennis Richie and Ken Thompson working on a PDP-11.

So, the first Unix was written in the Assembler program of a PDP-7 machine, as we have now discussed though this is not going to make it easily portable to another type of architecture.

At this stage and because of the success of Unix Bell Labs now chooses to re-sponsor the project.

1971 - 1973

B is still considered too slow, so the team worked to develop Unix in a faster development program called New B or NB. They could now also afford to upgrade to a later model of the PDP range called a PDP11/45.

The C Programming language was developed in 1972 as a result of Ken Thompson and his team wanting to have a language to write Unix in. Although Ken Thompson worked with C initially eventually they needed more functionality which Dennis Ritchie then added.

It is also at this time that Unix "pipes" are also now developed, and this is seen as a milestone because of the power it added to the system ^[1]

Unix now had its own language and philosophy. Its power was generated by stringing programs together not by any one individual program.

A quote from "A quarter Century of Unix" by P Salus" states:

write programs that do one thing and do it well.
write programs that work together
write programs that handle text streams, because that is a universal interface.

1973 - 1974

More and more requests are coming in to AT&T to allow other companies and users to use the Unix system.

At this stage Unix is firmly entrenched at Universities and Colleges and AT&T refusing to supply bug-fixes and support on the system forced users to work together. (The start of Unix User Groups.)

Unix had been sold as a text processing system at AT&T internally and here the developers and users were the same community and therefore got direct feedback for new product and for bugs etcetera, Support was right there in same company, maybe even on the same office floor.

By using research organizations at Universities the bright varsity students got sucked up into this type of company after their studying, this was beneficial to research organizations and they continued to give the system to students.

Unix is still used these days used to teach students computer science.

The US patent office held the rights at this stage.

1974 - 1975

There are now 500 installations throughout the United States, mainly at Universities.

After 1974 military and commercial enterprises started demanding licenses to use Unix and AT&T decided to close the source and supply only binary distributions.

Berkley UCB did a lot of development on DARPA TCP/IP (bright brains for a good price), and the students also started adding on various other utilities, ultimately deciding to write Unix from scratch. (BSD Unix)

BSD3 utilities are available in System V Unix, when installing the operating system you should be asked if you would like to install the BSD Utilities, they will be installed into the /usr/ucb directory.

1976 - 1978

Unix, is able to be ported to an IBM 360, an Interdata 7/32 and an Interdata 8/32 proving that Unix is portable to systems other than those manufactured by DEC.

1978 "The C Programming Language" by Ritchie is published.

1978 Bill Joy creates "the "vi" editor a full screen editor, and at the same time he sees the need "to optimize the code for several different types of terminals, he decided to consolidate screen management by using an interpreter to redraw the screen. The interpreter was driven by the terminal's characteristics - termcap was born,". P Sulcas

1979

All other Unixs' branch from these two variants of the Unix code, AT&T Unix and BSD Unix. (See timeline below).

The release of AT&T Version 7 was the start of many of the Unix ports, the 32 bit ports and a product called Xenix, (an SCO and Microsoft joint product, and the fist Unix port that could run on an 8086 chip).

1980

By 1980, AT&T found that the operating system was a viable option for commercial development. Microprocessors were becoming very popular, and many other companies were allowed to license UNIX from AT&T. These companies ported UNIX to their machines. The simplicity and clarity of UNIX tempted many developers to enhance the product with their own improvements, which resulted in several varieties of UNIX.

1977 to 1983

From 1977 to 1982, Bell Labs combined features from the AT&T versions of UNIX into a single system called UNIX System 3.

Bell Labs then enhanced System 3 into System 4, a system that was only used internally at Bell Labs.

After further enhancements, System V was released and in 1983, AT&T officially announced their support for System V.

1982 Sun developed the Sparc processor, licensed BSD Unix called it SUN OS.

1983/4 Then licensed AT&T System V, made their changes and called that version Solaris. There is a lot of cross coding and an interesting note is that if though if doing the "uname" (uname is a command that supplies details of the current operating system for your interest) command on Solaris the report says SunOS is the operating system.

1985 - Some quotable quotes - "Xenix is the operating system future" and "640 KB memory is enough for anyone"

1989

In 1989, AT&T organized that System V, SUNOS, XENIX, and Berkeley 4xBSD were combined into one product called System V Release 4.0. This new product was created to ensure that there was one version of UNIX that would work on any machine available at that time.

The different versions of UNIX prompted AT&T to form a UNIX International Consortium. The aim of this consortium was to improve the marketing of UNIX, since the market was starting to demand clarity on standardizing the product.

1992 to 1998

By 1992, UNIX was readily available on an Intel platform, providing mainframe-type processing power on a PC. This made UNIX appealing to the end-user market.

Vendor	Hardware	Operating System (Unix based)
HP	PARisc	HP-UX
IBM	RS6000 / Power PC	AIX
Digital / DEC / Compaq	Alpha	Digital Unix
NCR		DG-UX
SCO	Intel PC Compatible	SCO Xenix, SCO Unix, SCO Open Server 5, UnixWare 7

Source code has changed hands a few times:

year	Owner of Source code
1969	AT&T
1993	Novell
1995	SCO
2001	Caldera, which started trading under the name "The SCO Group" in 2002

Note
Besides licensing Unix System V to vendors, Novell marketed its own flavor of Unix to the consumer market, called UnixWare. When Novell sold the Unix business to SCO, it transferred the Unix trademark to X/Open Company Ltd. now the Open Group www.opengroup.org SCO inherited UnixWare 2 from Novell and continued selling it under the SCO brand.

Note

Besides licensing Unix System V to vendors, Novell marketed its own flavor of Unix to the consumer market, called UnixWare.
When Novell sold the Unix business to SCO, it transferred the Unix trademark to X/Open Company Ltd. now the Open Group www.opengroup.org
SCO inherited UnixWare 2 from Novell and continued selling it under the SCO brand.

This is the story of Linux

Figure 1.4. Professor Andy Tannebaum

985 Professor Andy Tanenbaum wrote a Unix like operating system from scratch, based on System V standards POSIX and IEEE, called MINIX for i386 for Intel PC aimed at university computer science research students.

MINIX was also bundled with a popular computer science operating system study book by that author. Although the operating system was free the book was to be purchased.

A Finnish student called Linus Torvald first came into contact with Unix like systems through his use of this MINIX at the university of Helsinki Finland in Computer Science.

Linus Torvald wanted to upgrade MINIX and put in features and improvements, but Andrew Tanenbaum wanted Minix the way it was and so Linus decided write his own kernel.

He released Linux on the Internet as an Open Source product and under his own license and then later in 1991 under the GPL.

	If you want to travel around the world and be invited to speak at a lot of different places, just write a Unix operating system.
-- Linus Torvald

Figure 1.5. Linus Torvald

The FSF (Free Software Foundation), started by Richard Stallman, as a development effort to promote the use of Free Software, Stallman recognized the need to write a free and open source Unix-like operating system so that people could have a Unix system under a non-propriety non-restrictive commercial license

The FSF started a project called GNU to fulfill this aim GNU stands for "GNU is not Unix" (a recursive acronym).

By 1991 GNU had already amassed a compiler (GCC- GNU C Compiler), a C library, both very critical components of an operating system, and all associated generic Unix base programs (ls, cat, chmod etcetera).

They were missing a kernel, which was going to be called the GNU HURD (HURD is not yet complete 2004 April).

The FSF naturally adopted the Linux kernel to complete the GNU system to produce what is known as the GNU/Linux operating system, which is the correct term for all distributions of Linux like Red Hat Linux and SuSE Linux.

1994 Linux 1.0 release

Figure 1.6. Tux, the Linux mascot

Ref: http://learnlinux.tsf.org.za/courses/build/internals/internals-all.html#history

Null Pointer

2008-05-12T14:11:00.002+05:30

Q: What is this infamous null pointer, anyway?

A: The language definition states that for each pointer type, there is a special value--the ``null pointer''--which is distinguishable from all other pointer values and which is ``guaranteed to compare unequal to a pointer to any object or function.'' That is, a null pointer points definitively nowhere; it is not the address of any object or function. The address-of operator & will never yield a null pointer, nor will a successful call to malloc.[footnote] (malloc does return a null pointer when it fails, and this is a typical use of null pointers: as a ``special'' pointer value with some other meaning, usually ``not allocated'' or ``not pointing anywhere yet.'')

A null pointer is conceptually different from an uninitialized pointer. A null pointer is known not to point to any object or function; an uninitialized pointer might point anywhere. See also questions 1.30, 7.1, and 7.31.

As mentioned above, there is a null pointer for each pointer type, and the internal values of null pointers for different types may be different. Although programmers need not know the internal values, the compiler must always be informed which type of null pointer is required, so that it can make the distinction if necessary (see questions 5.2, 5.5, and 5.6).

Q: How do I get a null pointer in my programs?

A: With a null pointer constant.

According to the language definition, an ``integral constant expression with the value 0'' in a pointer context is converted into a null pointer at compile time. That is, in an initialization, assignment, or comparison when one side is a variable or expression of pointer type, the compiler can tell that a constant 0 on the other side requests a null pointer, and generate the correctly-typed null pointer value. Therefore, the following fragments are perfectly legal:

 char *p = 0;
 if(p != 0)

(See also question 5.3.)

However, an argument being passed to a function is not necessarily recognizable as a pointer context, and the compiler may not be able to tell that an unadorned 0 ``means'' a null pointer. To generate a null pointer in a function call context, an explicit cast may be required, to force the 0 to be recognized as a pointer. For example, the Unix system call execl takes a variable-length, null-pointer-terminated list of character pointer arguments, and is correctly called like this:

 execl("/bin/sh", "sh", "-c", "date", (char *)0);

If the (char *) cast on the last argument were omitted, the compiler would not know to pass a null pointer, and would pass an integer 0 instead. (Note that many Unix manuals get this example wrong; see also question 5.11.)

When function prototypes are in scope, argument passing becomes an ``assignment context,'' and most casts may safely be omitted, since the prototype tells the compiler that a pointer is required, and of which type, enabling it to correctly convert an unadorned 0. Function prototypes cannot provide the types for variable arguments in variable-length argument lists however, so explicit casts are still required for those arguments. (See also question 15.3.) It is probably safest to properly cast all null pointer constants in function calls, to guard against varargs functions or those without prototypes.

Q: Is the abbreviated pointer comparison ``if(p)'' to test for non-null pointers valid? What if the internal representation for null pointers is nonzero?

A: It is always valid.

When C requires the Boolean value of an expression, a false value is inferred when the expression compares equal to zero, and a true value otherwise. That is, whenever one writes

 if(expr)

where ``expr'' is any expression at all, the compiler essentially acts as if it had been written as

 if((expr) != 0)

Substituting the trivial pointer expression ``p'' for ``expr'', we have

 if(p) is equivalent to if(p != 0)

and this is a comparison context, so the compiler can tell that the (implicit) 0 is actually a null pointer constant, and use the correct null pointer value. There is no trickery involved here; compilers do work this way, and generate identical code for both constructs. The internal representation of a null pointer does not matter.

The boolean negation operator, !, can be described as follows:

 !expr is essentially equivalent to (expr)?0:1
  or to ((expr) == 0)

which leads to the conclusion that

 if(!p) is equivalent to if(p == 0)

``Abbreviations'' such as if(p), though perfectly legal[footnote] , are considered by some to be bad style (and by others to be good style; see question 17.10).

Bookmarks

2008-05-02T12:07:00.008+05:30

GCC
http://www.cfdvs.iitb.ac.in/~amv/gcc-int-docs/#gccdocs
http://gcc.gnu.org/wiki/StructureOfGCC

Filesystem Hierarchy Standard

http://www.pathname.com/fhs/

Process Virtual Memory

http://www.linux-tutorial.info/modules.php?name=MContent&pageid=322#pagetop

Procfs

http://www.ibm.com/developerworks/library/l-proc.html
http://www.linuxforums.org/misc/procfs_from_the_inside.html

GNU Toolchain

http://webusers.npl.uiuc.edu/~yangrz/Make.html
http://sources.redhat.com/autobook/autobook/autobook_toc.html#SEC_Contents
http://www.seul.org/docs/autotut/#intro
http://www.pma.caltech.edu/~physlab/ph21_winter06/make.html

Socket Programming

http://www.tenouk.com/cnlinuxsockettutorials.html

Difference betn vfork & fork

2007-12-27T17:58:00.000+05:30

quick question: what’s the difference between fork() and vfork() system calls ?

quick answer: vfork() system call creates a process that shares the memory address space of its parent.

details:

fork() is implemented by linux as a clone() system call whose flags parameter specifies both a SIGCHLD signal and all the clone flags cleared and whose child_stack parameter is 0.

vfork() is implemented by linux as a clone() system call whose flags parameter specifies both a SGCHLD signal and flags CLONE_VM and CLONE_VFORK and whose second parameter is 0.

[ discussion: copy on write ]

This is a concept of making the process creation using fork() efficient in that instead of copying the parent’s address space while process creation, it is shared but as soon as either of them write on the page, kernel allocates a new page and assigns it to the writer process.

Most of the time, forking is required just to run a new process in which case it’s a waste to copy the whole parent address space.

source* http://whatilearned2day.wordpress.com/2007/02/05/fork-and-vfork/

Some systems have a system call vfork(), which was originally
designed as a lower-overhead version of fork(). Since
fork() involved copying the entire address space of the process,
and was therefore quite expensive, the vfork() function was
introduced (in 3.0BSD).

However, since vfork() was introduced, the
implementation of fork() has improved drastically, most notably
with the introduction of `copy-on-write', where the copying of the
process address space is transparently faked by allowing both processes
to refer to the same physical memory until either of them modify
it. This largely removes the justification for vfork(); indeed, a
large proportion of systems now lack the original functionality of
vfork() completely. For compatibility, though, there may still be
a vfork() call present, that simply calls fork() without
attempting to emulate all of the vfork() semantics.

As a result, it is very unwise to actually make use of any of the
differences between fork() and vfork(). Indeed, it is
probably unwise to use vfork() at all, unless you know exactly
why you want to.

The basic difference between the two is that when a new process is
created with vfork(), the parent process is temporarily
suspended, and the child process might borrow the parent's address
space. This strange state of affairs continues until the child process
either exits, or calls execve(), at which point the parent
process continues.

This means that the child process of a vfork() must be careful to
avoid unexpectedly modifying variables of the parent process. In
particular, the child process must not return from the function
containing the vfork() call, and it must not call
exit() (if it needs to exit, it should use _exit();
actually, this is also true for the child of a normal fork()).

Source* http://www.unixguide.net/unix/programming/1.1.2.shtml

During the fork() system call the Kernel makes a copy of the parent process�s address space and attaches it to the child process.But the vfork() system call do not makes any copy of the parent�s address space, so it is faster than the fork() system call. The child process as a result of the vfork() system call executes exec() system call. The child process from vfork() system call executes in the parent�s address space (this can overwrite the parent�s data and stack ) which suspends the parent process until the child process exits.

Source* http://www.kyapoocha.com/unix-interview-questions/difference-between-the-fork-and-vfork-system-call/

During the fork() system call the Kernel makes a copy of the parent process’s address space and attaches it to the child process.
But the vfork() system call do not makes any copy of the parent’s address space, so it is faster than the fork() system call. The child process as a result of the vfork() system call executes exec() system call. The child process from vfork() system call executes in the parent’s address space (this can overwrite the parent’s data and stack ) which suspends the parent process until the child process exits.

Source* http://www.technicalinterview.info/difference-between-the-fork-and-vfork-system-call/

Kernel Compiletion (make target)

2007-12-22T17:48:00.000+05:30

Informational Targets

Target

Description

kernelrelease

Displays the current kernel version, as determined by the build system.

kernelversion

Displays the current kernel version, as told by the main Makefile. This differs from the kernelrelease target in that it doesn’t use any additional version information based on configuration options or localversion files.

Cleaning Targets

Target	Description
clean	Removes most of the files generated by the kernel build system, but keeps the kernel configuration.
mrproper	Removes all of the generated files by the kernel build system, including the configuration and some various backup files.
distclean	Does everything mrproper does and removes some editor backup and patch leftover files.

Configuration Targets

Target	Description
config	Updates the current kernel configuration by using a line-oriented program.
menuconfig	Updates the current kernel configuration by using a text-based menu program.
xconfig	Updates the current kernel configuration by using a QT-based graphical program.
gconfig	Updates the current kernel configuration by using a GTK+-based graphical program.
oldconfig	Updates the current kernel configuration by using the current .config file and prompting for any new options that have been added to the kernel.
silentoldconfig	Just like oldconfig, but prints nothing to the screen except when a question needs to be answered.
randconfig	Generates a new kernel configuration with random answers to all of the different options.
defconfig	Generates a new kernel configuration with the default answer being used for all options. The default values are taken from a file located in the arch/$ARCH/defconfig file, where $ARCH refers to the specific architecture for which the kernel is being built.
allmodconfig	Generates a new kernel configuration in which modules are enabled whenever possible.

allyesconfig	Generates a new kernel configuration with all options set to yes.
allnoconfig	Generates a new kernel configuration with all options set to no.

Build Targets

Target	Description
all	Builds all of the different targets needed for this kernel to be able to be used. This includes both the modules and the static portion of the kernel.
vmlinux	Builds just the static portion of the kernel, not any loadable modules.
modules	Builds all of the loadable kernel modules for this configuration.
modules_install	Installs all of the modules into the specified location. If no location is specified with the INSTALL_MODULE_PATH environment variable, they are installed in the default root directory of the machine.
dir/	Builds all of the files in the specified directory and in all subdirectories below it.
dir/file.[o\|i\|s]	Builds only the specified file.
dir/file.ko	Builds all of the needed files and links them together to form the specified module.
tags	Builds all of the needed tags that most common text editors can use while editing the source code.
TAGS	Builds all of the needed tags that most common text editors can use while editing the source code.
cscope	Builds a cscope image, useful in source tree searches, of the source tree for the architecture specified by the configuration file (not all of the kernel source files).

Environment variables

Variable	Value	Description
V	0	This tells the build system to run in a quiet manner, showing only the file that is currently being built, and not the entire command that is running in order to build that file. This is the default option for the build system.
V	1	This tells the build system to operate in a verbose way, showing the full command that is being used to generate each of the specific files.
O	dir	This tells the build system to locate all output files in the dir directory, including the kernel configuration files. This allows the kernel to be built from a read-only filesystem and have the output placed in another location.
C	1	This checks all C files that are about to be built with the sparse tool, which detects common programming errors in the kernel source files. sparse can be downloaded using git from git://git.kernel.org/pub/scm/devel/sparse/sparse.git. Nightly snapshots can be found at http://www.codemonkey.org.uk/projects/git-snapshots/sparse/. More information on how to use sparse can be found in the Documentation/sparse.txt file in the kernel source tree.
C	2	This forces all C files to be checked with the sparse tool, even if they did not need to be built.

Packaging Targets

Target	Description
rpm	Builds the kernel first and then packages it up as a RPM package that can be installed.
rpm-pkg	Builds a source RPM package containing the base kernel.
binrpm-pkg	Builds a RPM package that contains a compiled kernel and modules.
deb-pkg	Builds a Debian package that contains the compiled kernel and modules.
tar-pkg	Builds a tarball that contains the compiled kernel and modules.
targz-pkg	Builds a gzip-compressed tarball that contains the compiled kernel and modules.
tarbz2-pkg	Builds a bzip2-compressed tarball that contains the compiled kernel and modules.

Documentation Targets

Target	Description
xmldocs	Builds the kernel documentation as XML DocBook files.
psdocs	Builds the kernel documentation as PostScript files.
pdfdocs	Builds the kernel documentation as PDF files.
htmldocs	Builds the kernel documentation as HTML files.
mandocs	Builds the kernel documentation as a set of manpages, which can then be installed with the installmandocs target.

Architecture-Specific Targets

Target	Description
bzImage	Creates a compressed kernel image and places it in the arch/i386/boot/bzImage file. This is the default target for the i386 kernel build.
install	Installs the kernel image using the distribution-specific /sbin/installkernel program. Note that this does not install the kernel modules; that must be done with the modules_install target.
bzdisk	Creates a boot floppy image and writes it to the /dev/fd0 device.
fdimage	Creates a boot floppy image and places it in the file arch/i386/boot/fdimage. The mtools package must be present on your system in order for this to work properly.
isoimage	Creates a CD-ROM boot image and places it in the file arch/i396/boot/image.iso. The syslinux package must be present on your system in order for this to work properly.

Analysis Targets

Target	Description
checkstack	Generate a list of the functions that use the most of the kernel stack space.
namespacecheck	Generate a list of all of the kernel symbols and their namespaces. This will be a large list.

Process States

2007-12-21T18:43:00.000+05:30

R ------> running.
S -----> sleeping in an interruptible wait.
D ------> waiting in interruptible disk sleep.
Z ------> zombie.
T ----> traced or stopped (on a signal).
W ----> paging.

Linux Signals

2007-12-03T13:14:00.002+05:30

Signal	Description	Default Action
SIGABRT	Generated by the abort system call (POSIX)	Process terminates and dumps core
SIGALRM	A timer signal generated by the alarm system call (POSIX)	Process terminates
SIGBUS	Process attempted to use mis-or unaligned memory (4.2 BSD)	Process terminates and dumps core.
SIGCHLD	A child has stopped or terminated (POSIX)	Ignore
SIGCONT	Process continues if it is stopped (POSIX)	Continue (ignore if process is not stopped)
SIGEMT	Bus (hardware) error	Process terminates and dumps core
SIGFPE	Floating-point exception (POSIX)	Process terminates and dumps core
SIGHUP	Process received a hang-up on its controlling terminal or its controlling process died	Process terminates
SIGILL	Illegal instruction (POSIX)	Process terminates and dumps core
SIGINFO	The same as SIGPWR	Ignore
SIGINT	User generated a keyboard interrupt (POSIX)	Process terminates
SIGIO	Asynchronous I/O received (4.2 BSD)	Ignore
SIGIOT	I/O trap. Same as SIGABRT (4.2 BSD)	Process terminates and dumps core
SIGKILL	Kill (POSIX)	Process terminates, cannot catch or ignore
SIGLOST	Process lost a file lock	Process terminates
SIGPIPE	Process attempted to write to a pipe with no readers (POSIX)	Process terminates
SIGPOLL	Pollable event occured (System V)	Process terminates
SIGPROF	Profiling alarm clock set on a segment of code expired (4.2 BSD)	Process terminates
SIGPWR	System detected a power failure (System V)	Ignore

SIGQUIT	User generated a keyboard quit (POSIX)	Process terminates and dumps core
SIGSEGV	Process attempted to reference inaccessible memory (POSIX)	Process terminates and dumps core
SIGSTKFLT	Process generated a stack fault ("blew the stack")	Process terminates
SIGSTOP	Stop signal (POSIX)	Stop, cannot catch or ignore
SIGSYS	Bad argument to routine	Process terminates and dumps core
SIGTERM	Process received a termination signal (POSIX)	Process terminates
SIGTRAP	Process hit a trace or breakpoint trap (usually during debugging) (POSIX)	Process terminates and dumps core
SIGTSTP	User generated a stop from the keyboard (POSIX)	Stop
SIGTTIN	Process attempted to read from stdin while running in the background (POSIX)	Stop
SIGTTOU	Process attempted to write Stop to stdout while running in the background (POSIX)
SIGUNUSED	Unused signal	Process terminates
SIGURG	Urgent condition on socket (4.2 BSD)	Ignore
SIGUSR1	User-defined signal 1 (POSIX)	Process terminates
SIGUSR2	User-defined signal 2 (POSIX)	Process terminates
SIGVTALRM	Interval alarm clock expired (4.2 BSD)	Process terminates
SIGWINCH	The size of a terminal window changed (4.3 BSD, Sun)	Ignore
SIGXCPU	Process exceeded the amount of CPU time it can use (4.2 BSD)	Process terminates and dumps core
SIGXFSZ	Process tried to access or manipulate a file larger than the syste file size limit (4.2 BSD)	Process terminates and dumps core

bits/signum.h

System Call Error Codes

2007-12-03T11:54:00.000+05:30

Error No.	Error	Description
1	EPERM	The process lacks sufficient permissions to perform the operation it is attempting to perform.
2	ENOENT	The process is attempting to access a file or directory that does not exist.
3	ESRCH	No such process exists.
4	EINTR	A system call was interrupted.
5	EIO	Some sort of (usually hardware-related) I/O error occurred.
6	ENXIO	The I/O device or address does not exist.
7	E2BIG	The argument list passed to an exec call was too long.
8	ENOEXEC	The format of a binary that a process attempted to execute was incorrect (such as trying to run a SPARC binary on an x86 processor).
9	EBADF	An invalid file number was passed to a function that opens/close/reads/writes a file.
10	ECHILD	The process had no child process on which to wait.
11	EAGAIN	A process attempted to perform non-blocking I/O when no input was available.
12	ENOMEM	Insufficient memory is available for the requested operation.
13	EACCESS	Access to a file or other resource would be denied.
14	EFAULT	A bad pointer (one that points to inaccessible memory) was passed to a system call.
15	ENOTBLK	A process attempted to mount a device that is not a block device.
16	EBUSY	A process attempted to mount a device that is already mounted or attempted to unmount a filesystem currently in use.
17	EEXIST	Returned when you try to create a file that already exists.
18	EXDEV	Returned by the link call if the source and destination files are not on the same filesystem.
19	ENODEV	A process attempted to use a filesystem type that the kernel does not support.
20	ENOTDIR	A directory component in a pathname is not, in fact, a directory.
21	EISDIR	The filename component of a pathname is a directory, not a filename.
22	EINVAL	A process passed an invalid argument to a system call.
23	ENFILE	The system has reached the maximum number of open files it supports.
24	EMFILE	The calling process cannot open any more files because it has already opened the maximum number allowed.
25	ENOTTY	A process attempted to do terminal style I/O on a device or file that is not a terminal. This error is the famous "not a typewriter" message.
26	ETXTBSY	A process attempted to open a binary or library file that is currently in use.
27	EFBIG	The calling process attempted to write a file longer than the system maximum or the process's resource limits permit.
28	ENOSPC	A filesystem or device is full.
29	ESPIPE	A process attempted to lseek on a non-seekable file.
30	EROFS	A process attempted to write on a read-only filesystem.
31	EMLINK	The file being linked has reached the maximum number of links allowed.
32	EPIPE	The read end of a pipe is closed and SIGPIPE is being ignored or trapped.
33	EDOM	Set by math functions when an argument exceeds the function's domain.
34	ERANGE	Set by math functions when the result of the function can't be represented by the function's return type.
36	ENAMETOOLONG	A path or filename is too long.
38	ENOSYS	The system call invoked has not been implemented.
39	ENOTEMPTY	A directory on which rmdir was called is not empty.
40	ELOOP	A path involves too long a chain of symbolic links.

Manpages

2007-12-01T14:46:00.000+05:30

Number	Description
1	Executable programs or shell commands.
2	System calls (functions provided by the kernel)
3	Library calls (functions within program libraries)
4	Special files (usually found in /dev)
5	File formats and conventions (/etc/fstab, /proc)
6	Games
7	Miscellaneous (including macro packages and conventions), for example, man(7), groff(7)
8	System administration commands (usually only for root)
9	Kernel routines (nonstandard)

beparas

UsrMove

Android Link's

Evolution of shells in Linux

Manage System Startup and Boot Processes on Linux with Upstart

BSD, System V, Upstart and systemd init, Oh My...

Managing Startup Services

Vim Tips

How do I make changes to a package and capture them using ltib

Programming tips

ssh login problem

Interview

ioctl

मराठी भाषेची ताकद

Translation Limits

NAND Types

Linux in Hollywood

Video Links

Welcome script

NAND Types

Tips & Tricks

How to count how many processes each user is running in Linux

How to see what is in an RPM without installing it?

1. Create a temp directory

2. Change directory

3. Now extract the RPM

Disable/Enable Auto-Mount in Ubuntu 10.04/10.10

Maximum On-Disk Sizes of the Filesystems

Kbuild

What is the difference between tty & ttyS

IP Networking Control Files

Command Hacks

How to set IP address, Subnet mask , and gateway

Linux System Calls Details

Control Keys

env command

Linux History

1955

1966

1969 to 1970

Assembler/ compilers / hardware architecture

1971 - 1973

1973 - 1974

1974 - 1975

1976 - 1978

1979

1980

1977 to 1983

1989

1992 to 1998

This is the story of Linux

Null Pointer

Bookmarks

Filesystem Hierarchy Standard

Difference betn vfork & fork

Kernel Compiletion (make target)

Process States

Linux Signals

System Call Error Codes

Manpages

BSD, System V, Upstart and systemd `init`, Oh My...