How To by Examples

[Linux] whiptail simple example

2011-11-03T22:23:00.000-07:00

Simple whiptail example.

#! /bin/bash
if (whiptail --title "PPP Configuration" --backtitle "Welcome to SEUL" --yesno "
Do you want to configure your PPP connection?" 10 40 )
then
echo -e "\nWell, you better get busy!\n"
elif (whiptail --title "PPP Configuration" --backtitle "Welcome to
SEUL" --yesno " Are you sure?" 7 40)
then
echo -e "\nGood, because I can't do that yet!\n"
else
echo -e "\nToo bad, I can't do that yet\n"
fi

Credit goes to http://archives.seul.org/seul/project/Feb-1998/msg00069.html

[Ubuntu] ccache

2011-11-02T21:26:00.000-07:00

compiler caching for gcc, g++

here goes an example

$ sudo apt-get install ccache

$ PATH=$PATH:/usr/lib/ccache

next time you compile with gcc, g++, it is faster

[Error] Package sun-java6-jdk is not available, but is referred to by another package.

2011-11-02T20:41:00.000-07:00

Ubuntu 11.10 (Oreinic)

If this error happens, just follow this.

$ sudo add-apt-repository "deb http://archive.canonical.com/ lucid partner"

# note that we use lucid repo, although we use oreinic, it works for me anyway

then

$ sudo apt-get update

$ sudo apt-get install sun-java6-jdk

[Linux] screen simple how to by example

2011-11-02T18:21:00.000-07:00

Assume you have 'a remote' and 'a local'.

At the remote, you access via ssh and launch 'screen -S test'.

Then, you will see a terminal-look which is no difference, but in background, there are lot of difference.

First, this terminal-look is not the ssh session that you connect but the session stored in the remote itself (i.e., screen session).

The difference is that although the ssh session dies unexpectedly, screen session does not die.

You can whenever connect this session by screen command.

Here are the most frequently used screen commands

screen -S test (create a new screen session named as 'test')

screen -ls (list the currently created screen sessions)

the results would look like this

16373.test1 (11/03/2011 10:29:08 AM) (Multi, detached)

15342.test2 (11/03/2011 10:30:08 AM) (Multi, attached)

Multi means that multiple attachments are possible.

Attached means that this session is already attached by someone.

If you want to join the attached session, you should use screen -x.

If you want to join the detached session, you should use screen -r.

For example

$ screen -r test1 #reattaching screen session

$ screen -x test2 #attach the currently attached screen session (it looks like a remote desktop of terminal version)

In order to use screen -x, make sure that it is Multi.

At the screen session, if you type 'exit' then the screen session quits.

If you just want to leave the session without quiting it, you type Ctrl+A and d.

it means Detaching from the current screen session.

[Latex] error ! I can't find file `pcrr7t'.

2011-11-02T05:26:00.000-07:00

If you encounter the following error " ! I can't find file `pcrr7t'. " while you compile a tex in ubuntu, try this

sudo apt-get install texlive-fonts-recommended

then try again

[Ubuntu] Expanding workspace in Ubuntu 11.10

2011-11-02T05:20:00.000-07:00

first install compizconfig-settings-manager

$ sudo apt-get install compizconfig-settings-manager

then

# for vertical size

$ gconftool-2 --type=int --set /apps/compiz-1/general/screen0/options/vsize 4

$ gconftool-2 --type=int --set /apps/compiz-1/general/screen0/options/hsize 4

[Linux] terminator restoring layout

2011-11-02T04:44:00.000-07:00

Terminator version above 0.91

1) open up a terminator.

2) split the terminals the way you want

3) left click, and choose preferences

4) go to the layouts tab

5) at the left bottom, click add button

6) write a name for adding layout (for example, test)

7) now launch terminator at any terminal with the added layout

( e.g., terimnator -l test)

[Linux] Tip for assuring download file

2011-11-01T23:40:00.000-07:00

In some projects, they give tutorials about how to download and install.

Some of them also provide with checksum (such as the following)

The SHA-1 checksum for repo is e1fd3bef059d152edf4d0522590725d317bc637f

you can easily verify the checksum by various sum binaries such as md5sum, sha1sum, etc

$ sha1sum bin/repo

e1fd3bef059d152edf4d0522590725d317bc637f bin/repo

it is useful in the sense that the downloaded file is not corrupted but also useful to find out that the downloaded file is right on track on without any further update on the project since fast evolving project, there could be un-noted changes which brings you to the hell of install and configuration bugs

[Android] services

2011-11-01T19:14:00.000-07:00

racoon service: acoon speaks the IKE (ISAKMP/Oakley) key management protocol, to establish security associations with other hosts. The SPD (Security Policy Database) in the kernel usually triggers racoon.

http://linux.die.net/man/8/racoon

drm service: stands for digital rights management for protecting contents.

dbus service: dbus (Desktop Bus) is a simple inter-process communication (IPC) open-source system for software applications to communicate with one another. An implementation of dbus supports most POSIX operating systems.

http://en.wikipedia.org/wiki/D-Bus

zygote service: this service half-initializes the android apps and if the android app is launching (e.g., clicked by user) the other half is initialized using zygote service.

[Android] can't create '/system/bin/busybox': read-only filesystem

2011-10-31T22:25:00.000-07:00

You just need to change the read-only option of the mounted filesystem. (FYI it uses yaffs2 filesystem)

In my case,

$ adb shell

$ su

$ mount -o rw,remount /dev/block/mmcblk0p4 /system

application: how to change init.rc

$ mount -o remount,rw rootfs /

and change it!!

[Android] connecting android in linux

2011-10-31T22:16:00.000-07:00

first, download android-sdk and use

$ sudo adb start-server # you should start the server as root

$ adb shell # you can connect to the android shell

[PYTHON] waiting for key input

2011-10-29T22:11:00.001-07:00

raw_input("Press Enter to continue")

[Openstack] QEMU at most memory 2047 occurs

2011-10-29T21:34:00.000-07:00

try to use euca-run-instance xxx -k key -t m1.tiny

m1.tiny only requests 512MB memory

[Openstack] dnsmasq bind error

2011-10-29T20:48:00.000-07:00

If you see bind error while running openstack nova-compute or nova-network,

it probably is the generic dnsmasq launched by /etc/init.d

Just /etc/init.d/dnsmasq stop

and try again

[Openstack] rabbitmq rejects with invalid credentials

2011-10-29T03:01:00.000-07:00

When rabbitmq log shows invalid credentials and rejects nova-services to join the cluster,

it probably means that the password is wrong.

nova-services in default use guest/guest (id/pw) for rabbitmq.

you can add (or change) the a user (or pw) with the following commands

add a user guest/guest

$ rabbitmqctl add_user guest guest

change the pw

$ rabbitmqctl change_password guest guest

[Openstack] Suggestion on the tight correlation to the mysql database and nove-service processes

2011-10-28T05:15:00.001-07:00

If we stop the service, such as 'stop nova-network'
it would be appreciated if the corresponding service is deleted in mysql services table in nova.

[Openstack] nova.conf configuration

2011-10-28T05:09:00.000-07:00

in nova.conf configuration flag, routing_source_ip flag should use 'numbered-ip' such as 192.168.1.1, but not the host name.
I thinkg openstack guys try to tell us by naming the flag as 'routing_source_IP'.
Since it is used as the input param to iptable-restore, thus if you use host name on 'routing_source_ip' nova-network will unexpected die.
If you try to run the nova-network again, it will be on deadlock, since the module that performs this use external lock in /var/log/nova/ and hangs in ps aux.
This makes you think nova-network is working fine but NO IT IS NOT.

It takes half a day to figure out what the heck is going on.

[OpenStack] possible self-deadlock?

2011-10-28T05:06:00.000-07:00

Openstack manages external lock in /var/lock/nova directories.

If a service, (in my case, nova-network) dies while it is acquiring the lock, nova-network never be able to run properly since it is waiting for the lock that will be never released. (since the process that acquires the lock was terminated unexpectedly).

Openstack servies should release all locks with 'launch-all' command things like that.

[OpenStack] nova-xxx who registers itself to DB as service?

2011-10-28T04:17:00.000-07:00

At function nova/service.py, line around 143

service_ref = db.service_get_by_args(ctxt,
self.host,
self.binary)

function!

[Python] Starting document for python paste

2011-10-27T19:25:00.000-07:00

About WSGI application and WSGI middleware: http://pythonpaste.org/url-parsing-with-wsgi.html

About deployment and ini-configuration : http://pythonpaste.org/deploy/

How To Resize ext3 Partitions Without Losing Data

2011-10-26T02:19:00.000-07:00

From http://www.howtoforge.com/linux_resizing_ext3_partitions

1 Preliminary Note

(I run all the commands in this tutorial as the root user, so make sure you're logged in as root. If you are on a Ubuntu system, you can become root like this:

sudo su

)

I have tested this on a Ubuntu Edgy Eft desktop system that has all files in one large partition (around 10 GB, device /dev/sda1). The partitioning looks like this:

df -h

Filesystem Size Used Avail Use% Mounted on
/dev/sda1 9.5G 4.1G 4.9G 46% /
varrun 94M 132K 94M 1% /var/run
varlock 94M 0 94M 0% /var/lock
udev 10M 52K 10M 1% /dev
devshm 94M 0 94M 0% /dev/shm
lrm 94M 18M 77M 19% /lib/modules/2.6.17-10-generic/volatile

The partition that is to be resized must be unmounted when we do the resizing; obviously this is not possible if this is the partition that holds all important system files like in this example. Therefore we download a Live Linux-CD such as Knoppix from which we boot later on (if you have physical access to the system). If it is a remote system that you don't have physical access to, you need a rescue system on that system (a lot of hosting companies offer dedicated servers with rescue systems nowadays) that you can boot into (instead of Knoppix), and this rescue system must have the following tools: fdisk, umount, fsck,tune2fs, e2fsck, resize2fs.

If the partition that you want to resize doesn't hold any system files (such as /home partitions, partitions for backups, etc.), you don't need a Knoppix Live-CD or a rescue system, because all steps can be run from the original system.

If you want to resize partitions on production systems, please back up your data before, because it is possible you lose all your data if you don't calculate the size of your new partition correctly (especially when shrinking a partition)! You have been warned! Tutorials about backups can be found here:http://www.howtoforge.com/taxonomy_menu/1/34

I'm going to resize /dev/sda1 in this tutorial. If your partition is named differently, please replace /dev/sda1 with your own device (e.g. /dev/hda5, /dev/sdb3, etc.).

2 Shrinking An ext3 Partition

This chapter is about shrinking an ext3 partition. I want to shrink /dev/sda1 in this example. First we gather some details on our original system:

Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda1 9859036 4234908 5123304 46% /
varrun 95480 132 95348 1% /var/run
varlock 95480 0 95480 0% /var/lock
udev 10240 52 10188 1% /dev
devshm 95480 0 95480 0% /dev/shm
lrm 95480 17580 77900 19% /lib/modules/2.6.17-10-generic/volatile

df -B 4k

Filesystem 4K-blocks Used Available Use% Mounted on
/dev/sda1 2464759 1058727 1280826 46% /
varrun 23870 33 23837 1% /var/run
varlock 23870 0 23870 0% /var/lock
udev 2560 13 2547 1% /dev
devshm 23870 0 23870 0% /dev/shm
lrm 23870 4395 19475 19% /lib/modules/2.6.17-10-generic/volatile

df -h

fdisk -l

Disk /dev/sda: 10.7 GB, 10737418240 bytes
255 heads, 63 sectors/track, 1305 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

Device Boot Start End Blocks Id System
/dev/sda1 * 1 1247 10016496 83 Linux
/dev/sda2 1248 1305 465885 5 Extended
/dev/sda5 1248 1305 465853+ 82 Linux swap / Solaris

fdisk -s /dev/sda1

10016496

Then we shut down the system and boot into our Knoppix Live-CD (or your rescue system) (if the partition you want to resize doesn't hold any system files, you can do everything from the original system; the steps are the same, just omit booting into Knoppix/your rescue system).

shutdown -r now

After Knoppix has booted, open a terminal and become root by running

/dev/sda1 should be unmounted by default, but you can run

umount /dev/sda1

to go sure.

Then run

fsck -n /dev/sda1

The output looks like this:

fsck 1.38 (30-Jun-2005)
e2fsck 1.38 (30-Jun-2005)
/dev/sda1: clean, 159037/1254176 files, 1095299/2504124 blocks

Next we remove the journal from /dev/sda1, thus turning it into an ext2 partition:

tune2fs -O ^has_journal /dev/sda1

The output looks like this:

tune2fs 1.38 (30-Jun-2005)

Then run

e2fsck -f /dev/sda1

e2fsck 1.38 (30-Jun-2005)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
/dev/sda1: 164178/1254176 files (0.6% non-contiguous), 1051617/2504124 blocks

Now we resize our file system with resize2fs. resize2fs can resize ext2 file systems, but not ext3 file systems, that's why we had to turn /dev/sda1 to ext2. Currently, 4.1GB are used on /dev/sda1 (see the df -h output above), So it's safe to shrink it from 10GB to about 6GB (if you make it smaller than 4.1GB, you will lose data!). Therefore we run

resize2fs /dev/sda1 6000M

The output is as follows:

resize2fs 1.38 (30-Jun-2005)
Resizing the filesystem on /dev/sda1 to 1536000 (4k) blocks.
The filesystem on /dev/sda1 is now 1536000 blocks long.

Please take note of the amount of blocks (1536000) and their size (4k). We need that soon.

Now we delete our /dev/sda1 partition (don't be afraid, no data will be lost) and create a new, smaller one (but still big enough to hold our resized file system!). We can do this with fdisk:

fdisk /dev/sda

(Yes, it's /dev/sda, not /dev/sda1.)

The number of cylinders for this disk is set to 1305.
There is nothing wrong with that, but this is larger than 1024,
and could in certain setups cause problems with:
1) software that runs at boot time (e.g., old versions of LILO)
2) booting and partitioning software from other OSs
(e.g., DOS FDISK, OS/2 FDISK)

Type m to get a list of all commands:

Command (m for help): m
Command action
a toggle a bootable flag
b edit bsd disklabel
c toggle the dos compatibility flag
d delete a partition
l list known partition types
m print this menu
n add a new partition
o create a new empty DOS partition table
p print the partition table
q quit without saving changes
s create a new empty Sun disklabel
t change a partition's system id
u change display/entry units
v verify the partition table
w write table to disk and exit
x extra functionality (experts only)

Now we delete partition no. 1 (/dev/sda1):

Command (m for help): d
Partition number (1-5): 1

Next we create a new /dev/sda1 partition. It was a primary partition before, so we choose p again, and again it is our partition no. 1:

Command (m for help): n
Command action
l logical (5 or over)
p primary partition (1-4)
p
Partition number (1-4): 1

Now comes the crucial part - we are asked about the size of the new partition. The first cylinder is no problem, it is the one from the fdisk -l output at the beginning of this chapter (1).

First cylinder (1-1305, default 1): 1

But we don't have a value for the last cylinder of our new partition. Fortunately, we can specify the size in kilobytes (K), so we calculate the size like this:

We multiply the amount of blocks from the resize2fs output (1536000) by the size of a block (4k), and to go sure the partition is big enough, we add 3 to 5% to it (3% was enough for me, but if you want to go sure take 5%):

1536000 * 4k * 1.03 = 6328320k

So we prepend that value with a + sign and replace the small k with a capital one (K) and enter it:

Last cylinder or +size or +sizeM or +sizeK (1-1247, default 1247): +6328320K

Our original /dev/sda1 had the bootable flag (see the fdisk -l output from the beginning of this chapter), so we must add it to our new /dev/sda1 again:

Command (m for help): a
Partition number (1-5): 1

Now let's write our new partition table and exit fdisk:

Command (m for help): w
The partition table has been altered!

Calling ioctl() to re-read partition table.

WARNING: Re-reading the partition table failed with error 16: Device or resource busy.
The kernel still uses the old table.
The new table will be used at the next reboot.
Syncing disks.

Now we reboot the system, and again we boot into our Knoppix system (rescue system; original system if resized partition doesn't hold system files):

shutdown -r now

Become root again (on Knoppix run

)

and then run this:

fsck -n /dev/sda1

The output should look like this:

fsck 1.38 (30-Jun-2005)
e2fsck 1.38 (30-Jun-2005)
/dev/sda1: clean, 159036/765536 files, 1047239/1536000 blocks

Then we create the journal on our new /dev/sda1, thus turning it into an ext3 partition again:

tune2fs -j /dev/sda1

tune2fs 1.38 (30-Jun-2005)
Creating journal inode: done
This filesystem will be automatically checked every 30 mounts or
0 days, whichever comes first. Use tune2fs -c or -i to override.

Now we are done. Shut down the system and boot into the original system:

shutdown -r now

If everything goes well, the original system will boot up, and no data has been lost. Now we can gather some details about our new partitioning and compare them with the information we collected at the beginning of this chapter:

Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda1 6047868 4224140 1639408 73% /
varrun 95480 132 95348 1% /var/run
varlock 95480 0 95480 0% /var/lock
udev 10240 52 10188 1% /dev
devshm 95480 0 95480 0% /dev/shm
lrm 95480 17580 77900 19% /lib/modules/2.6.17-10-generic/volatile

df -B 4k

Filesystem 4K-blocks Used Available Use% Mounted on
/dev/sda1 1511967 1056035 409852 73% /
varrun 23870 33 23837 1% /var/run
varlock 23870 0 23870 0% /var/lock
udev 2560 13 2547 1% /dev
devshm 23870 0 23870 0% /dev/shm
lrm 23870 4395 19475 19% /lib/modules/2.6.17-10-generic/volatile

df -h

Filesystem Size Used Avail Use% Mounted on
/dev/sda1 5.8G 4.1G 1.6G 73% /
varrun 94M 132K 94M 1% /var/run
varlock 94M 0 94M 0% /var/lock
udev 10M 52K 10M 1% /dev
devshm 94M 0 94M 0% /dev/shm
lrm 94M 18M 77M 19% /lib/modules/2.6.17-10-generic/volatile

fdisk -l

Disk /dev/sda: 10.7 GB, 10737418240 bytes
255 heads, 63 sectors/track, 1305 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

Device Boot Start End Blocks Id System
/dev/sda1 * 1 789 6337611 83 Linux
/dev/sda2 1248 1305 465885 5 Extended
/dev/sda5 1248 1305 465853+ 82 Linux swap / Solaris

fdisk -s /dev/sda1

6337611

[Linux] Managing users and groups

2011-10-25T05:50:00.000-07:00

cat /etc/passwd

[Linux Kernel] The difference between /dev/mem and /dev/kmem

2011-10-22T01:57:00.000-07:00

/dev/mem is the character device for physical memory and /dev/kmem is the character device for kernel virtual address space

Also check out /dev/fb* for frame-buffer memory (video).

Would it be possible to change the hostname through accessing /dev/mem?

[Cheating in C] How to know a certain function is called by which function.

2011-10-21T01:24:00.000-07:00

When you want to know which function calls a function name A(), and there are many other functions that call A(), here is simple cheating.

First, find out the condition that you want to know who calls A() and make a hard coding there like this.

if( the condition you want ) {

int *a=0;

*a=0;

}

and run with GDB

[Linux] The difference between block and character device

2011-10-21T01:19:00.000-07:00

The one big difference is how you handle the device. When you perform open, close, read, write, seek, etc.

For block devices, it reads and writes in the unit of a block of bytes size.

For character devices, it reads and writes in the unit of a byte.

More important thing to remember is that block devices are able to random-access such as hard-disk, but character devices are in stream such as keyboard.