For example, awk is a virtual package provided by original-awk, mawk and gawk.

Trying to install it directly yields:

Reading package lists... Done
Building dependency tree       
Reading state information... Done
Package awk is a virtual package provided by:
  original-awk:i386 2012-12-20-4
  mawk:i386 1.3.3-17ubuntu2
  gawk:i386 1:4.1.1+dfsg-1
  original-awk 2012-12-20-4
  mawk 1.3.3-17ubuntu2
  gawk 1:4.1.1+dfsg-1
You should explicitly select one to install.

E: Package 'awk' has no installation candidate

However many virtual packages are needed as dependencies by the packages installed by default, for example awk itself is needed by base-files, which checking the APT logs is installed along with a bunch of other packages through apt-get --yes; somehow APT ends up picking one of the three automatically (I'm pretty sure that's mawk, but that's not the point of the question).

How does APT choose the specific package to install in this case?

I'm curious as to whether Canonical tracks Ubuntu usage, and if so how, whether there are "official" figures and where I can find them.

So, does Canonical track Ubuntu usage?

If so, how?

Are there "official" figures?

Where can I find them?

Note: I'm mostly interested in seeing such figures, if any exists.

From man 1 tar:

[...]
     -p, --preserve-permissions, --same-permissions
           extract information about file permissions (default for superuser)
[...]
     --no-same-permissions
           apply the user's umask when extracting permissions from the archive
           (default for ordinary users)
[...]

From this I understand that by default extracted files' permissions are set based on the user's umask, unless the user is root:

% umask
002

So files extracted by me should have permissions 664 (666-002).

However:

% touch foo
% chmod +x foo
% ls -l
total 0
-rwxrwxr-x 1 user user 0 nov  3 19:36 foo
% tar cf foo.tar foo
% rm foo
% tar xf foo.tar 
% ls -l
total 12
-rwxrwxr-x 1 user user     0 nov  3 19:36 foo
-rw-rw-r-- 1 user user 10240 nov  3 19:36 foo.tar

I.e., Tar is preserving the permissions of the original file even though I didn't pass the -p, --preserve-permissions or --same-permissions switch.

Nonetheless if I pass the --no-same-permissions switch:

% tar xf foo.tar --no-same-permissions
% ls -l
total 12
-rwxrwxr-x 1 user user     0 nov  3 19:36 foo
-rw-rw-r-- 1 user user 10240 nov  3 19:36 foo.tar

Still Tar is preserving the permissions of the original file.

Can someone please explain why is that?

Long story short, I have an external USB hard drive formatted using a MBR partition table, and I want to install Ubuntu in UEFI mode in a ~23.40 GB unallocated space before a ~442.33 GB NTFS partition that I need to keep:

To install Ubuntu in UEFI mode I need the partition table of the drive to be formatted as gpt.

I don't think there's an easy / direct way to convert a MBR partition table to a gpt partition table, so I'm also looking for the complicated / indirect way.

For example I think something can be done by noting down the NTFS partition start, writing the new partition table and adding the NTFS partition to the new partition table, but I've never done this and I have no idea where to start; furthermore I don't wish to try this for the first time in this case, since I'm not really confident with this stuff and I can't afford losing the NTFS partition I need to keep.

Consider you want to run this command in bash:

echo -n "Command of a specific length will break at the second run attempt."

Here's the output for a 24x80 TTY:

ubuntu@ubuntu:~$ echo -n "Command of a specific length will break at the second 
run attempt."
Command of a specific lenght will break at the second run attempt.ubuntu@ubuntu:
~$ 

Consider you want to run the same command again.

As soon as you hit ↑:

ubuntu@ubuntu:~$ echo -n "Command of a specific lenght will break at the second
run attempt."
Command of a specific lenght will break at the second run attempt.ubuntu@ubuntu:
run attempt."ommand of a specific lenght will break at the second r

This happens with commands of a certain size which don't print a newline at the end.

This is extremely annoying. So far I haven't found any solution to this, and I think everyone who's experiencing this issue would be really grateful to someone who has a solution for this.

How can I reliably check which is the last time an Ubuntu machine has been connected to the internet?

In case this is not possible, a way to check the last time an Ubuntu machine has been connected to a network would be good enough.

Since I mostly use my laptop as a desktop, I'm trying to set its CPU to its maximum frequency.

The CPU is an Intel Core i5-3337U (dual-core with Hyper-Threading), which caps at 2.5GHz (with 2 active cores) and at 2.70GHz (with 1 active core) using the Intel Turbo Boost Technology.

Before starting, I tested which frequency the CPU could reach under load using LINPACK, to see if despite any active power-saving feature it could have reached the nominal maximum value of 2.5GHz; it could (measured running watch -n 1 "cat /proc/cpuinfo | grep \"cpu MHz\"").

I chose to use the cpufreq-set approach: I've installed the cpufrequtils package and at first I tried to set the CPU governor to "performance" running cpufreq-set -g performance; I can't tell whether this impacted somehow the idle frequency's range, however the result was not satisfying: in this state the frequency of all the CPUs constantly dropped down and rose up in the 1.0GHZ-2.4GHZ range.

So I tried to set the CPU governor to "userspace", in order to eventually be able to set a fixed frequency; however the following error came up:

Error setting new values. Common errors:
- Do you have proper administration rights? (super-user?)
- Is the governor you requested available and modprobed?
- Trying to set an invalid policy?
- Trying to set a specific frequency, but userspace governor is not available,
   for example because of hardware which cannot be set to a specific frequency
   or because the userspace governor isn't loaded?

After some research, I discovered that the "userpace" governor is not available when using the intel_pstate driver; so I tried disabling it by adding intel_pstate=disable to the kernel parameters in /etc/defaults/grub and updating grub; however, after the reboot, nothing changed and I'm still unable to switch to the "userspace" governor.

tl;dr

How can I enable the "userpace" governor?

- or -

How can I set the CPU frequency to always stay at its maximum?

I have an ASUS F552CL laptop with Ubuntu 15.04 installed.

The laptop comes with a dedicated nVidia GeForce GT 710M graphics card.

I have installed and enabled all the proprietary drivers suggested in Software Updates - Additional Drivers:

When I try to switch to the dedicated graphics card using NVIDIA X Server Settings, a message pops up asking me to log out and log back in to apply the changes:

And it looks like the dedicated graphics card has been selected:

However, if I log out and log back in the integrated graphics card shows up as the card in use:

I also tried to reboot instead of to log out and log back in but the integrated graphics card keeps showing up as the card in use.

When I run gksudo nvidia-settings in Terminal, after having closed NVIDIA X Server Settings I get the following message:

ERROR: nvidia-settings could not find the registry key file. This file
       should have been installed along with this driver at
       /usr/share/nvidia/nvidia-application-profiles-key-documentation. The
       application profiles will continue to work, but values cannot be
       preopulated or validated, and will not be listed in the help text.
       Please see the README for possible values and descriptions.

Update #2: I had a great missunderstanding about the -p option, now it's clear to me that it's used to process all the files provided as an argument, but I still don't quite understand why this is needed when reading the input from stdin.

Update #1: I've noticed that the -p option is always needed (at least when performing a substitution), even when using the deafult separator (newline character) and when the input file is a single line, and I don't quite understand why dropping the -p option to process a single line (which seems to be something appropriate) breaks everything (i.e. no output).

For example, running echo -n 'test' | perl -pe 's/test/newstring/' outputs newstring as expected, but echo -n 'test' | perl -e 's/test/newstring/' outputs nothing.

Original question:

Why does slurping the whole file reading from stdin in a Perl command (e.g. perl -0777 -e [...]) still needs the -p option to be given in order to actually process the file (e.g. perl -0777 -pe [...])?

I understand that the -p option places a loop around each line of the command, but why isn't changing (in this case removing) the separator enough for Perl to process the file? Or, why is it necessary, despite the fact that the file is going to be processed only once, to tell Perl to place a loop around each line of the command?

In a non-English Ubuntu-it.org wiki page it's stated that the UEFI partition MUST be always placed at the start of the disk.

This is not the case in the English Ubuntu Community Help Wiki page.

So does the UEFI partition either "MUST" or "SHOULD" (assuming a bad wording in the former page) be first for some reason? If so why? Or this is totally irrelevant?

This is my understanding about the usage of &, disown and nohup:

• <command>: runs the process within the Terminal's current bash instance, in the foreground (i.e. the process is listed as a bash foreground job and stdin, stdout and stderr are still bound to the terminal); not immune to hangups;
• <command> &: runs the process within the Terminal's current bash instance, in the background (i.e. the process is listed as a bash background job and stdin, stdout and stderr are still bound to the terminal); not immune to hangups;
• <command> & disown: runs the process within the Terminal's current bash instance, in the background, but the process is detached from the bash's jobs' list (i.e. the process is not listed as a bash foreground / background job and stdin, stdout and stderr are still bound to the terminal); immune to hangups;
• nohup <command> & disown: runs the process within the Terminal's current bash instance, in the background, but the process is detached from the bash's jobs' list (i.e. the process is not listed as a bash foreground / background job and stdin, stdout and stderr are not still bound to the terminal);immune to hangups;

So, aside from nohup <command> & disown blocking stdin and redirecting stdout and stderr to nohup.out by default, it seems to me like it can be considered totally equivalent to <command> & disown.

Is the above all correct? Any misconception?

Consider this command:

echo "string.with.dots" | sed 's/\(.*\)\.\(.*\)/\1\n\2/'

(Matches into a first capturing group any character until the last . and into a second capturing group any character after it.)

This outputs:

string.with
dots

Reasonably (I think) I tought that using anchors in the right combination would have managed to reverse such behavior (i.e. the match would have been string for the first capturing group and with.dots for the second capturing group), but:

echo "string.with.dots" | sed 's/^\(.*\)\.\(.*\)/\1\n\2/'
echo "string.with.dots" | sed 's/^\(.*\)\.\(.*\)$/\1\n\2/'
echo "string.with.dots" | sed 's/\(.*\)\.\(.*\)$/\1\n\2/'

All output:

string.with
dots

I don't know how the pattern matching is implemented, but it seems that it always privileges the patterns closer to the start of the string rather than those closer to the end of the string (despite any present ^ or missing $).

How can this behavior be changed (i.e. not how to write an hard-coded solution to this example, but how to reverse the pattern-matching priority order into sed or into regexes in general), if possible?

I expected printf %s '\<octal_character_value>' to do the trick, but it doesn't:

printf %s '\101'

Outputs:

\101

I need to print a list of "full" relative paths of all the files present in a directory and in its sub-directories. I used to do this with du and grep:

du -a <path_to_directory> | grep -Po '[0-9]+\t\/\K.*'

But du replaces part of the paths with dots if they are too long.

Which is a good alternative?

Parsing ls is not an option.

I ran up against this question, and i found it quite interesting.

While researching for that, i found out that a solution had been posted already here on AskUbuntu, plus multiple times on StackOverflow and on Unix & Linux, but all the solutions provided involved the use of xclip or xsel, which are not available in a default Ubuntu installation (i.e. they're not present in a Live DVD, for example).

Question: How to copy the stdout of a command to the clipboard in a default Ubuntu installation?

Some days ago I decided to wipe my 750 GB hard disk in order to sell it, so I booted Ubuntu off a live DVD and started the process with sudo dd if=/dev/zero of=/dev/sda. I left dd running during the night. When I came back in the morning I discovered that at some point of the process Ubuntu freezed. I'm unable to determine at which point of the process the freeze happened, because whenever it happened it happened while the screen saver was on, so i wasn't able see bash's output.

Question: How do I avoid starting dd over again?

I'm trying to mount a custom usb drive image created with fdisk. This is how I created the image:

1. Created a file of the exact same size of an old usb drive image used as a model: dd if=/dev/zero of=image.img count=30712320 (size: 15724707840 B, 15.7 GB)
2. Created the partition table: in fdisk: o
3. Created the partition: in fdisk: n, p, 1, enter, enter
4. Toggled the partition type to W95 FAT 32 (LBA): in fdisk: t, c
5. Set the boot flag to on: in fdisk: a, 1
6. Wrote the changes to the image: in fdisk: w

Output of fdisk -l image.img:

Disk image.img: 15.7 GB, 15724707840 bytes
193 heads, 9 sectors/track, 17681 cylinders, total 30712320 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0xc8fac3e1

    Device Boot      Start         End      Blocks   Id  System
image.img1   *        2048    30712319    15355136    c  W95 FAT32 (LBA)

Everything seems ok, but the problem is I'm not able to mount the image:

1) sudo mount image.img /media/image:

mount: you must specify the filesystem type

2) sudo mount -t vfat image.img /media/image:

mount: wrong fs type, bad option, bad superblock on /dev/loop0, missing codepage or helper program, or other error
In some cases useful info is found in syslog - try dmesg | tail  or so

3) sudo mount -o offset=1048576 image.img /media/image (1048576=starting sector number*sector size):

mount: you must specify the filesystem type

4) sudo mount -t vfat -o offset=1048576 image.img /media/image (1048576=starting sector number*sector size):

mount: wrong fs type, bad option, bad superblock on /dev/loop0, missing codepage or helper program, or other error
In some cases useful info is found in syslog - try dmesg | tail  or so

Why does this happen?

What I expect from two commands which always produce the same output on their own, is them to always produce the same output when put in a pipeline, but apparently this is not the case for tar | gzip:

~/test$ ls
~/test$ dd if=/dev/urandom of=file bs=10000000 count=1
1+0 records in
1+0 records out
10000000 bytes (10 MB) copied, 0,877671 s, 11,4 MB/s // Creating a 10MB random file
~/test$ tar cf file.tar file // Archiving the file in a tarball
~/test$ tar cf file1.tar file // Archiving the file again in another tarball
~/test$ cmp file.tar file1.tar // Comparing the two output files
~/test$ gzip -c file > file.gz // Compressing the file with gzip
~/test$ gzip -c file > file1.gz // Compressing the file again with gzip
~/test$ cmp file.gz file1.gz // Comparing the two output files
~/test$ tar c file | gzip > file.tar.gz // Archiving and compressing the file
~/test$ tar c file | gzip > file1.tar.gz // Archiving and compressing the file again
~/test$ cmp file.tar.gz file1.tar.gz // Comparing the output files
file.tar.gz file1.tar.gz differ: byte 5, line 1 // File differs at byte 5
~/test$ cmp -i 5 file.tar.gz file1.tar.gz // Comparing the output files after byte 5
~/test$ 

Adding to this, even tar cfz file.tar file on his own always produces different outputs:

~/test$ tar cfz file2.tar file // Archiving and compressing the file
~/test$ tar cfz file3.tar file // Archiving and compressing the file again
~/test$ cmp file2.tar.gz file3.tar.gz // Comparing the output files
file2.tar.gz file3.tar.gz differ: byte 5, line 1 // File differs at byte 5
~/test$ cmp -i 5 file2.tar.gz file3.tar.gz // Comparing the output files after byte 5
~/test$ 

While splitting the pipeline finally produces an output that makes sense:

~/test$ gzip -c file.tar > file4.tar.gz
~/test$ gzip -c file.tar > file5.tar.gz
~/test$ cmp file4.tar.gz file5.tar.gz 
~/test$ 

It looks like whatever happens happens only when tar's output is piped directly into gzip.

What is the explanation of this behavior?

It has been determined already in this question that tar cannot read input from stdin.

How else can a dd output be archived directly possibly without using any compression? The purpose of doing everything in a single task is to avoid to write the dd output to the target disk twice (once as a raw file and once as an archive), and to avoid to perform two different tasks, which is a waste of time (since the input file must be read and written and the output read, processed and written again), and can be impossible if the target drive is almost full.

I'm planning to do multiple backups of drives, partitions and folders, and I'd like to benefit both from the ease of having everything stored into a single file and from the speed of each backup / potential restore task.

I need to use tar in a pipeline inside a shell script to archive and compress some files.

After having read the manpage for tar I was able to make tar output to stdout by running it along with the -O argument, but I wasn't able to find out how to make it input from stdin. Since many commands read from stdin if no other input it's specified, I tried:

pv ~/foo | tar c -O ~/foo.tar

but that didn't work:

tar: Cowardly refusing to create an empty archive

Try 'tar --help' or 'tar --usage' for more information.

How can I make tar read input from stdin?