python: script to check Minimal requirements to compile the Kernel

Used to check the minimal requirment to compile the kernel which are declared in below sites:
      https://www.kernel.org/doc/html/v4.15/process/changes.html


Program:

# Kernel minimal requriment check by Velraj.K
# Check : http://velrajcoding.blogspot.in

import subprocess
import shutil
import os

APT_INSTALL_COMMAND = "sudo apt-get --assume-yes install "
APT_UPDATE      = "sudo apt update --assume-yes"

DICT_NAME      = 'name'
DICT_CMD       = 'command'
existing_sofware = []
not_available_list  = []
installing_err   = []

def is_tool_present(name):
    # var = os.system('which vim') will display the output on console and store success value 0 to var
    # store the output of which in command line value into the var.
    var = os.popen('which ' + name).read()
    ret = var.find(name)
    return ret != -1


def install_software(software):
    # Check the command is present in Linux OS
    if is_tool_present(software[DICT_CMD]):
        existing_sofware.append(software)
    else:
        not_available_list.append(software)

# Display the table header.

def table_header():

    # The value 1,20,25 & 20 are constant based on the column name

    print "{:<20} {:<15} {:<20} {:<20}".format('Program Name', '\"Command\"', '\"Available\"', '\"Not available\"')

    line = []

    for i in range(1, 72):

        # creat the list with - for display a line

        line.append('-')

    # convert the list into a string other wise display as ['-', '-', '-', ...] 

    str1 = ''.join(str(e) for e in line)

    print str1

# To display the row content in the table

def table_row(table_row):

    # The value 22, 23,23 & 20 are constant based on the column adjust value row

        print "{:<23} {:<15} {:<21} {:<20}".format(table_row[0], table_row[1], table_row[2], table_row[3])

def result_tablular():

    # Display the result table header

    table_header()

    # Display the row value in the tabl

    for name in existing_sofware:

        table_row([name[DICT_NAME], name[DICT_CMD], 'Yes', 'NA'])

    for name in not_available_list:

        table_row([name[DICT_NAME], name[DICT_CMD], 'NA', 'Yes'])

def main():

    # Dictionary usage example: 

    #    myStruct = {'field1': 'some val', 'field2': 'some val'}

    #    print myStruct['field1']

    #    myStruct['field2'] = 'some other values'

    # List of Minimum requirement package

    dict_list_software = [ {DICT_NAME:'GNU C', DICT_CMD:'gcc'},

                           {DICT_NAME:'GNU make', DICT_CMD:'make'},

                           {DICT_NAME:'binutils', DICT_CMD:'ld'},

                           {DICT_NAME:'util-linux', DICT_CMD:'fdformat'},

                           {DICT_NAME:'module-init-tools', DICT_CMD:'depmod'},

                           {DICT_NAME:'e2fsprogs', DICT_CMD:'e2fsck'},

                           {DICT_NAME:'jfsutils', DICT_CMD:'fsck.jfs'},

                           {DICT_NAME:'reiserfsprogs', DICT_CMD:'reiserfsck'},

                           {DICT_NAME:'xfsprogs', DICT_CMD:'xfs_db'},

                           {DICT_NAME:'squashfs-tools', DICT_CMD:'mksquashfs'},

                           {DICT_NAME:'btrfs-progs', DICT_CMD:'btrfsck'},

                           {DICT_NAME:'pcmciautils', DICT_CMD:'pccardctl'},

                           {DICT_NAME:'quota-tools', DICT_CMD:'quota'},

                           {DICT_NAME:'PPP', DICT_CMD:'pppd'},

                           {DICT_NAME:'isdn4k-utils', DICT_CMD:'isdnctrl'},

                           {DICT_NAME:'nfs-utils', DICT_CMD:'showmount'},

                           {DICT_NAME:'procps', DICT_CMD:'ps'},

                           {DICT_NAME:'oprofile', DICT_CMD:'oprofiled'},

                           {DICT_NAME:'udev', DICT_CMD:'udevd'},

                           {DICT_NAME:'grub', DICT_CMD:'grub'},

                           {DICT_NAME:'mcelog', DICT_CMD:'mcelog'},

                           {DICT_NAME:'iptables', DICT_CMD:'iptables'},

                           {DICT_NAME:'openssl & libcrypto', DICT_CMD:'openssl'},

                           {DICT_NAME:'bc', DICT_CMD:'bc'},

                           {DICT_NAME:'Sphinx', DICT_CMD:'sphinx-build'} ]

    # Check and install the list of software available in the software_name

    for name in dict_list_software:

        install_software(name)

    result_tablular()

if __name__ == "__main__":

    main()

python: script to install C Linux development needed packages

The Following C linux development packages are installed using python script:

• Vim
• cscope
• screen
• make
• cmake
• gdb
• gcc

Program:

import subprocess
import shutil
import os

APT_INSTALL_COMMAND = "sudo apt-get --assume-yes install "
APT_UPDATE      = "sudo apt update --assume-yes"

existing_sofware = []
installing_list  = []
installing_err   = []

def is_tool_present(name):
    # var = os.system('which vim') will display the output on console and store success value 0 to var
    # store the output of which in command line value into the var.
    var = os.popen('which ' + name).read()
    ret = var.find(name)
    return ret != -1

def install_software(software):
    #subprocess.call("sudo apt-get update", shell=True)
    if is_tool_present(software):
        print(software + " is already installed in the system, so not installing \n");
        existing_sofware.append(software)

    else:
        # run the install command in the shell,
        ret = subprocess.call(APT_INSTALL_COMMAND + software, shell=True)
        # check is the software is installed successfully, if success add in installing_list otherwise add in _err.
        if ret == 0:
            print "Installed " + software + " Successfully"
            installing_list.append(software)
        else:
            installing_err.append(software)

# Display the table header.
def table_header():
    # The value 1,20,25 & 20 are constant based on the column name
    print "{:<15} {:<20} {:<25} {:<20}".format('Package', '\"Newly Installed\"', '\"Error while installing\"', '\"Existing package\"')
    line = []
    for i in range(1, 82):
        # creat the list with - for display a line
        line.append('-')
    # convert the list into a string other wise display as ['-', '-', '-', ...]
    str1 = ''.join(str(e) for e in line)
    print str1

# To display the row content in the table
def table_row(table_row):
    # The value 22, 23,23 & 20 are constant based on the column adjust value row
        print "{:<22} {:<23} {:<23} {:<20}".format(table_row[0], table_row[1], table_row[2], table_row[3])


def result_tablular():
    # Display the result table header
    table_header()
    # Display the row value in the tabl
    for name in installing_list:
        table_row([name, 'Yes', 'NA', 'NA'])

    for name in installing_err:
        table_row([name, 'NA', 'Yes', 'NA'])

    for name in existing_sofware:
        table_row([name, 'NA', 'NA', 'Yes'])

def main():
    # The follwoing software used for automake
    #      automake, automake1.11
    #      libtool --> Used in automake file as libtoolize command
    # binutils-dev --> includes header files and static libraries necessary to build programs which use the GNU BFD library
    # build-essential --> for libc-devel
    software_name = ['vim', 'cscope', 'screen', 'make', 'cmake', 'gdb', 'gcc', 'git', 'automake', 'libtool',
                     'binutils-dev', 'libc6', 'build-essential']

    ret = subprocess.call(APT_UPDATE, shell=True)
    # Check and install the list of software available in the software_name
    for name in software_name:
        install_software(name)

    result_tablular()

if __name__ == "__main__":
    main()

  

Reverse the given sentence

Reverse the give sentence:

#include <stdio.h>
#include <string.h>

#define STR_BUFFER_256    256
#define ARG_LENGTH        64


int reverse_sentence(char *str, char *str_result, int str_len)
{
        char str_sentence[STR_BUFFER_256] = {'\0'};
        char *arg[ARG_LENGTH] = {0}, *temp = NULL;
        int count = 0, rev_count;

#if 0 // This logic is wrong because strncpy won't return a number of byte written
        int ret = 0;

        ret = strncpy(str_sentence, str, sizeof(STR_BUFFER_256));
        if (ret >= STR_BUFFER_256) {
                printf("Truncation the sentence \n");
        }
#else
        memset(str_sentence, '\0', str_len);
        strncpy(str_sentence, str, str_len);

        if (str_sentence[STR_BUFFER_256 - 1] != '\0') {
                printf("Truncation the sentence \n");
        }

#endif

#ifdef DEBUG
        printf("Original = %s copied varable = %s \n", str, str_sentence);
#endif
        temp = strtok(str_sentence, " ");
        arg[count] = temp;
        count++;

        while (temp && (count < ARG_LENGTH)) {
                temp = strtok(NULL, " ");
                arg[count] = temp;
                count++;
        }


        if (temp && (count >= ARG_LENGTH)) {
                temp = strtok(NULL, " ");
                if (temp != NULL) {
                        printf("No of word is more than %d so taking first %d word only\n", ARG_LENGTH, ARG_LENGTH);
                }
        }

        /* arg[count] last value will be a NULL, but count is point to next to NUll */
        count--;

       /* Count point the sentinal value, decerement to point to the last word */
        count--;
#ifdef DEBUG
        printf("inst cout = %d rev c= %d \n", count, rev_count);
#endif
        for (rev_count = count; rev_count >= 0 ; rev_count--) {
                strncat(str_result, arg[rev_count], str_len);
                if (rev_count != 0) {
                        strncat(str_result, " ", str_len);
                }
        }

        return 0;
}

int main()
{
        char str[STR_BUFFER_256] = "Velraj is coming from chennai";
        char str_result[STR_BUFFER_256] = {'\0'};

        reverse_sentence(str, str_result, sizeof(str_result));
        printf("\n\t\t Original sentence = %s \n\t\t Reverse sentence = %s \n", str, str_result);

        return 0;
}

/* Output:
   ------
   velraj@velraj-HEC41:~/CProgram$ gcc -g sentence_reverse_hcl.c
   velraj@velraj-HEC41:~/CProgram$ ./a.out

   Original sentence = Velraj is coming from chennai
   Reverse sentence = chennai from coming is Velraj
   velraj@velraj-HEC41:~/CProgram$

   '-g' is used to include the symbols, if we need to debug with gdb then compile with -g only give the
   symbol value.

 */

Difference between 2 jiffies

What is jiffies:

• The original kernel timer system (called the "timer wheel) was based on incrementing a kernel-internal value (jiffies) every timer interrupt.
• The timer interrupt rate (and jiffy increment rate) is defined by a compile-time constant called HZ.
• Different platforms use different values for HZ.
• The kernel used 100 as the value for HZ, yielding a jiffy interval of 10 ms.
• With 2.4, the HZ value for i386 was changed to 1000, yeilding a jiffy interval of 1 ms.
• Process:
• When jiffy count is incremented then a process gets time to run.
• The jiffies are incremented by the timer interrupt that tells the scheduler to reschedule
•  If the process calls yield() or sleep(), for example, then rescheduling takes place immediately.
• Thus the context switch to a next available running process not necessarily occurs at the jiffy boundary.
• It lists /proc/timer_list and /proc/timer_stats.
• Tick generation:
• It is updated every tick 
• tick is triggered by timer/clock interrupt.
• The interrupt is generated by Intel 8253 or HPET hardware
• So it won't update until the hardware was property initialized.
• Difference:
• There is a better solution to ensure correct jiffy wrap handling in *ALL* kernel code: make jiffy wrap in first five minutes of uptime.
• #define INITIAL_JIFFIES (0xffffffffUL & (unsigned long)(-300*HZ))
• Hence jiffies is using the full 32 bit, after that overflow happen.
• So jiffies.h file comment as maximum jiffie value is (MAX_INT >> 1) is a false comment.
• Don't use MAX_JIFFY_OFFSET as max value since this is wrong.
• https://lwn.net/Articles/22874/

Program:

Wrong program:

• This below code is wrong, because jiffies is using the full 32 bit confirmed by after bootup jiffies overflow in 5 min, 
• So after bootup just checked the jiffies value, it is using full 32 bit before overflow.
• Hence below code is wrong, this is wrongly used in some of kernel code.

inline unsigned long jiffies_time_diff(unsigned long start, unsigned long end)
{
    if (end >= start)
        return end - start;

    return end + (MAX_JIFFY_OFFSET - start);
}

Correct program:

inline unsigned long jiffies_time_diff(unsigned long start, unsigned long end)
{  

       unsigned long diff = 0;

       /* This code is handle the overflow also, by converting to long.

            if jiffies start time is 13 and after overflowed end time is 5 then, coverting to sign

            difference value is -8, the 1st complement +1 value of -8 is stored as big value in unsiged diff.

            This is the correct difference */

       diff = (long)end - (long) start;

       return diff;
}

        

What does _r suffix mean?

• The suffix "_r" is historical, where the 'r' stood for "reentrant".
• A computer program or subroutine is called reentrant.
• if it can be interrupted in the middle of its execution and then safely be called again ("re-entered") before its previous invocations complete execution. 
• 
  
• Using global variable inside the function, ISR(interuppt call) may try to access our temporary changed global value in outside.
• Solution:
• Use the local variable instead of global variable will clear this issue
• _r reason:
• Using _r to make sure global variables are not affected.


• _r function will be thread safe.
• EG: strtok vs strtok_r
• strtok_r() is thread-safe.
• The strtok_r() function is a reentrant version of strtok().
• Strtok_r uses the 3arg as the local variable instead of global variable to record the progress through s1.
• https://en.wikipedia.org/wiki/Reentrancy_(computing)

Return:





The strtok() and strtok_r() functions return a pointer to the next token, or NULL if there
       are no more tokens.

Attributes:





For an explanation of the terms used in this section, see attributes(7).

       ┌───────────┬───────────────┬───────────────────────┐
       │Interface  │ Attribute     │ Value                 │
       ├───────────┼───────────────┼───────────────────────┤
       │strtok()   │ Thread safety │ MT-Unsafe race:strtok │
       ├───────────┼───────────────┼───────────────────────┤
       │strtok_r() │ Thread safety │ MT-Safe               │
       └───────────┴───────────────┴───────────────────────┘

Program:

/* strtok vs strtok_r by Velraj.K
   Check : http://velrajcoding.blogspot.in
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
    char *str1, *str2, *token, *subtoken;
    char *saveptr1, *saveptr2;
    char str_second[256] = {'\0'};
    int j;

    if (argc != 4) {
        fprintf(stderr, "Usage: %s string delim subdelim\n",
                argv[0]);
        exit(EXIT_FAILURE);
    }

    strncpy(str_second, argv[1], sizeof(str_second));

    printf("\n\n\t\t Do the token using strtok_r \n");

    /* use strtok_r */
    for (j = 1, str1 = argv[1]; ; j++, str1 = NULL) {
        token = strtok_r(str1, argv[2], &saveptr1);
        if (token == NULL)
            break;
        printf("%d: %s\n", j, token);

        for (str2 = token; ; str2 = NULL) {
            subtoken = strtok_r(str2, argv[3], &saveptr2);
            if (subtoken == NULL)
                break;
            printf(" --> %s\n", subtoken);
        }
    }
    printf("Original value = %s \n", argv[1]);

    printf("\n\n\t\tDo the token using strtok str_second = %s \n", str_second);
    /* Initialize the variable to NULL to start token again with strtok */
    str1 = NULL;
    str2 = NULL;
    token = NULL;
    subtoken = NULL;
    saveptr1 = NULL;
    saveptr2 = NULL;

    /* use strtok */
    for (j = 1, str1 = str_second; ; j++, str1 = NULL) {
        token = strtok(str1, argv[2]);
        if (token == NULL)
            break;
        printf("%d: %s\n", j, token);
#if 0 // Could not use the 2nd strtok with different delim because it uses the global pointer
        for (str2 = token; ; str2 = NULL) {
            subtoken = strtok(str2, argv[3]);
            if (subtoken == NULL)
                break;
            printf(" --> %s\n", subtoken);
        }
#endif
    }

    exit(EXIT_SUCCESS);
}

Output:

learn$ ./a.out this,isvelraj,check,strok,new , .

                 Do the token using strtok_r
1: this
 --> this
2: isvelraj
 --> isvelraj
3: check
 --> check
4: strok
 --> strok
5: new
 --> new
Original value = this

                Do the token using strtok str_second = this,isvelraj,check,strok,new
1: this
2: isvelraj
3: check
4: strok
5: new

Stack function argumen & local variable declaration order in stack

Program:

/*  Stack function argumen & local variable declaration order in stackprogram by Velraj.K
    Check : http://velrajcoding.blogspot.in
  */
#include <stdio.h>
#include <stdlib.h>

int global = 0;

int stack_no_argument()
{
        return 6;
}

void stack_no_arg_declar_call(int arg)
{
        int a;
        int b;

        printf("\n\t\t%s &argc = %p &a = %p &b = %p \n\t\t", __func__, &arg, &a, &b);
}

oid stack_no_arg_declar(int arg)
{
        int a[100];
        int b[200];
        int c[300];
        char chr[100];   /* Seems stack also it is taking extra bye, use only int is continue.
                          * but mixing char inbetween get extra bye on first a int and then this variable */
        int d[100];
        void *ptr = NULL;
        int *ptr_int;

        ptr = malloc(100);
        ptr_int = b;

        *(ptr_int + 200) = 1;
        printf("\n\t\t &a[0] = %p &a[99] = %p \n\t\t &b[0] = %p &b[199] = %p\n\t\t &c[0] = %p &c[299] = %p\n\t\t",
                        &a[0], &a[99], &b[0], &b[199], &c[0], &c[299]);

        printf("\n\t\t chr[0] = %p, &chr[99] = %p\n\t\t &d[0] = %p &d[99] = %p\n\t\t global = %p\n\t\t malloc= %p\n\t\t",
                        &chr[0], &chr[99], &d[0], &d[99],
                        &global, ptr);
        printf("\n\t\t &ptr = %p \n\t\t &ptr_int = %p \n\t\t",
                        &ptr, &ptr_int);
        printf("\n\t\t argc = %p \n\t\t a[0] = %d c[0] = %d \n\n",
                        &arg, a[0], c[0]);
       stack_no_arg_declar_call(100);
}

int stack_argument_seque(int a, int b, char ch, float *flo)
{
        b = a + ch;
        printf("Inside the function \n");
        return 10;
}



int main()
{
        float value = 0.0;
        int ret = 0;
/*
        ---- snip -----
        fstps   -20(%ebp)
        movl    $0, -16(%ebp)
        leal    -20(%ebp), %eax
        pushl   %eax
        pushl   $99   
        pushl   $2
        pushl   $1
        call    stack_argument_seque
        ---- snip -----
        Argument pushed into stack from right to left.
        Note: ASCII value of 'c' is 99.
*/

int stack_argument_seque(int a, int b, char ch, float *flo)
{
        b = a + ch;
        printf("Inside the function \n");
        return 10;
}



int main()
{
        float value = 0.0;
        int ret = 0;
/*
        ---- snip -----
        fstps   -20(%ebp)
        movl    $0, -16(%ebp)
        leal    -20(%ebp), %eax
        pushl   %eax
        pushl   $99   
        pushl   $2
        pushl   $1
        call    stack_argument_seque
        ---- snip -----
        Argument pushed into stack from right to left.
        Note: ASCII value of 'c' is 99.
*/

int stack_argument_seque(int a, int b, char ch, float *flo)
{
        b = a + ch;
        printf("Inside the function \n");
        return 10;
}



int main()
{
        float value = 0.0;
        int ret = 0;
/*
        ---- snip -----
        fstps   -20(%ebp)
        movl    $0, -16(%ebp)
        leal    -20(%ebp), %eax
        pushl   %eax
        pushl   $99   
        pushl   $2
        pushl   $1
        call    stack_argument_seque
        ---- snip -----
        Argument pushed into stack from right to left.
        Note: ASCII value of 'c' is 99.
*/


        ret = stack_argument_seque(1, 2, 'c', &value);
        stack_no_argument();
        stack_no_arg_declar(10);
}


Output:
   ------
   velraj@velraj-HEC41:~/CProgram$ ./a.out
Inside the function

                 &a[0] = 0xbfdd319c &a[99] = 0xbfdd3328
                 &b[0] = 0xbfdd332c &b[199] = 0xbfdd3648
                 &c[0] = 0xbfdd364c
                global = 0x804a02c
                  malloc= 0x942c410
                a[0] = 0 c[0] = 0


After add the char inbetween:
--------------------------
velraj@velraj-HEC41:~/CProgram$ ./a.out
Inside the function
Output:
   ------
   velraj@velraj-HEC41:~/CProgram$ ./a.out
Inside the function

                 &a[0] = 0xbfdd319c &a[99] = 0xbfdd3328
                 &b[0] = 0xbfdd332c &b[199] = 0xbfdd3648
                 &c[0] = 0xbfdd364c
                global = 0x804a02c
                  malloc= 0x942c410
                a[0] = 0 c[0] = 0


After add the char inbetween:
--------------------------
velraj@velraj-HEC41:~/CProgram$ ./a.out
Inside the function


                 &a[0] = 0xbfed0ac8 &a[99] = 0xbfed0c54
                 &b[0] = 0xbfed0de8 &b[199] = 0xbfed1104
                 &c[0] = 0xbfed1108 &c[299] = 0xbfed15b4
                 chr[0] = 0xbfed15b8, &chr[99] = 0xbfed161b
                 &d[0] = 0xbfed0c58 &d[99] = 0xbfed0de4
                 global = 0x804a02c
                 malloc= 0x855b410
                 a[0] = 0 c[0] = 1

        Here we are wring b+200 but it write on c[0], hece a first b second and 3rd is c, since stack botton start on top, hence address wise c a is long from stack.

        Output current:
        --------------
velraj@velraj-HEC41:~/CProgram$ ./a.out
Inside the function


                 &a[0] = 0xbf85fa58 &a[99] = 0xbf85fbe4
                 &b[0] = 0xbf85fd78 &b[199] = 0xbf860094
                 &c[0] = 0xbf860098 &c[299] = 0xbf860544
               
                 chr[0] = 0xbf860548, &chr[99] = 0xbf8605ab
                 &d[0] = 0xbf85fbe8 &d[99] = 0xbf85fd74
                 global = 0x804a02c
                 malloc= 0x80e9410
               
                 &ptr = 0xbf85fa50
                 &ptr_int = 0xbf85fa54
               
                 argc = 0xbf8605c0
                 a[0] = 0 c[0] = 1


                stack_no_arg_declar_call &argc = 0xbf85fa40 &a = 0xbf85fa24 &b = 0xbf85fa28

Diagram to understand:

Vim editor tips

Split into 2 screen:

  

• split your screen in multiple files horizontal: :sp <filepath>\

• switch between splitscreens with Ctrl+W

•  :vsp or :vp is for vertical split. Then use Ctrl+W <ARROW_KEYS> to move in panes.

:n -> Move to next file
:N -> Move to previous file

Vimdiff colorscheme:

List all the installed color schemes in VIM:

Type

:colorscheme then Space followed by TAB.

or as Peter said,

:colorscheme then Space followed by CTRLd

or path: /usr/share/vim/vim74/colors/b

Load different colorscheme when using vimdiff

if &diff
    colorscheme some_other_scheme
endif

Hence the .vimrc file content:

" Set colorscheme only to Vimdiff if use from command line
" Check the colorschme for vimdiff and collected below
"      pablo -> good, slate -> ok, blue -> Very dark

if &diff
    colorscheme pablo
endif

Complete .vimrc file content:

"Indents braces
set cindent



"Indents by 4 spaces
set shiftwidth=4



"Prevents spaces from being converted to tabs
"set expandtab



"To hightligth the search word"
set hlsearch



" Red line verital mark
"set cc=80



" Once it reace 79 it will automatically come to next line
"set tw=79



" always add a space after comma
" Enable it only if you keep on forgetting space after comma
" inoremap , ,<space>

" strcpy, strncpy, strcat, strncat, sprintf, strtok, memcpy are banned APIs.
" Highlight them as Error, to prevent accidental usage.
match Error /\<strcpy\>\|\<strncpy\>\|\<strcat\>\|\<strncat\>\|\<sprintf\>\|\<strtok\>\|\<memcpy\>/

fun! VerifySyntaxError()
        highlight default link LinuxError ErrorMsg

        syn match LinuxError / \+\ze\t/     " spaces before tab
        syn match LinuxError /\%>80v[^()\{\}\[\]<>]\+/ " virtual column 81 and more

        " Highlight trailing whitespace, unless we're in insert mode and the
        " cursor's placed right after the whitespace. This prevents us from having
        " to put up with whitespace being highlighted in the middle of typing
        " something
        autocmd InsertEnter * match LinuxError /\s\+\%#\@<!$/
        autocmd InsertLeave * match LinuxError /\s\+$/
endfunction

map <F5> :call VerifySyntaxError()<CR>



" Vel Adding list :
" For ctags, to use ctrl + ] option
set cscopetag

" Set colorscheme only to Vimdiff if use from command line
" Check the colorschme for vimdiff and collected below
"      pablo -> good, slate -> ok, blue -> Very dark

if &diff
    colorscheme pablo
endif