Merge lp:~noskcaj/ubuntu/saucy/i7z/i7z into lp:ubuntu/saucy/i7z

[Jackson Doak]

Merge from debian unstable. Fixes an RC bug.

[Matt Fischer (mfisch)]

Jackson,

You need to include the bug number in the changelog entry (LP: #XXXXXX). Also why did you revert the maintainer changes? What you removed is right for Ubuntu since we have Ubuntu changes. You can manually fix this or I think the update-maintainer script will do it for you (I've never used it)

3800 -Maintainer: Ubuntu Developers <email address hidden>
3801 -XSBC-Original-Maintainer: Andreas Beckmann <email address hidden>
3802 +Maintainer: Andreas Beckmann <email address hidden>

review: Needs Fixing

[lp:~noskcaj/ubuntu/saucy/i7z/i7z]

5. By Jackson Doak on 2013-08-15

Fix debian/control

[Matt Fischer (mfisch)]

Looks good. Uploaded

review: Approve

Unmerged revisions

5. By Jackson Doak on 2013-08-15

Fix debian/control

4. By Jackson Doak on 2013-08-14

* Merge from debian unstable. Remaining changes:
  - debian/control: Future-proof by adding x32 to the architecture list

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2013-03-16 21:16:14 +0000
+++ .pc/applied-patches	2013-08-15 05:58:18 +0000
@@ -1,1 +1,3 @@
-install-i7z_rw_registers
+install-i7z_rw_registers.patch
+hyphen-used-as-minus-sign.patch
+fix-insecure-tempfile.patch

=== added directory '.pc/fix-insecure-tempfile.patch'
=== added file '.pc/fix-insecure-tempfile.patch/.timestamp'
=== added directory '.pc/fix-insecure-tempfile.patch/GUI'
=== added file '.pc/fix-insecure-tempfile.patch/GUI/i7z_GUI.cpp'
--- .pc/fix-insecure-tempfile.patch/GUI/i7z_GUI.cpp	1970-01-01 00:00:00 +0000
+++ .pc/fix-insecure-tempfile.patch/GUI/i7z_GUI.cpp	2013-08-15 05:58:18 +0000
@@ -0,0 +1,687 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2009 Abhishek Jaiantilal
+ *
+ *   Under GPL v2
+ *
+ * ----------------------------------------------------------------------- */
+#include <memory.h>
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <time.h>
+#include <math.h>
+
+#include <QApplication>
+#include <QPushButton>
+#include <QProgressBar>
+#include <QWidget>
+#include <QVBoxLayout>
+#include <QGridLayout>
+#include <QLabel>
+#include <QThread>
+#include <QTimer>
+#include <QTime>
+
+
+#ifndef UINT32_MAX
+# define UINT32_MAX (4294967295U)
+#endif
+#include "../helper_functions.c"
+
+#define MAX_PROCESSORS_GUI 12
+
+bool global_in_i7z_main_thread = false;
+int socket_list[MAX_PROCESSORS_GUI];
+int core_list[MAX_PROCESSORS_GUI];
+struct cpu_heirarchy_info chi;
+struct cpu_socket_info socket_0, socket_1;
+unsigned int numCPUs;
+struct program_options prog_options;
+
+void Construct_Socket_Information_in_GUI(unsigned int *numCPUs) {
+    int socket_0_num=0, socket_1_num=1;
+    socket_0.max_cpu=0;
+    socket_0.socket_num=0;
+    int i;
+    for(i=0;i < 8; i++)
+        socket_0.processor_num[i]=-1;
+    socket_1.max_cpu=0;
+    socket_1.socket_num=1;
+    
+    for(i=0;i < 8; i++)
+        socket_1.processor_num[i]=-1;
+
+    construct_CPU_Heirarchy_info(&chi);
+    construct_sibling_list(&chi);
+//    print_CPU_Heirarchy(chi);
+    construct_socket_information(&chi, &socket_0, &socket_1, socket_0_num, socket_1_num);
+//    print_socket_information(&socket_0);
+//    print_socket_information(&socket_1);
+    *numCPUs = socket_0.num_physical_cores + socket_1.num_physical_cores;
+
+    //// FOR DEBUGGING DUAL SOCKET CODE ON SINGLE SOCKET, UNCOMMENT BELOW 2 lines
+//    memcpy(&socket_1, &socket_0, sizeof(struct cpu_socket_info));
+//    socket_1.socket_num=0;
+
+
+//    print_socket_information(&socket_0);
+//    print_socket_information(&socket_1);
+    *numCPUs = socket_0.num_physical_cores + socket_1.num_physical_cores;
+//    printf("My Widget: Num Processors %d\n",*numCPUs);
+
+    int k, ii;
+    k=0;
+    for (ii = 0; ii < socket_0.num_physical_cores ; ii++) {
+        if ( socket_0.processor_num[ii] != -1) {
+            core_list[k] = socket_0.processor_num[ii];
+            socket_list[k] = 0;
+            k++;
+        }
+    }
+    for (ii = 0; ii < socket_1.num_physical_cores ; ii++) {
+        if ( socket_1.processor_num[ii] != -1) {
+            core_list[k] = socket_1.processor_num[ii];
+            socket_list[k] = 1;
+            k++;
+        }
+    }
+}
+
+class MyThread:public QThread
+{
+public:
+    MyThread ();
+    void run ();
+    double *FREQ, *MULT;
+    long double *C0_TIME, *C1_TIME, *C3_TIME, *C6_TIME;
+};
+
+MyThread::MyThread ()
+{
+    Construct_Socket_Information_in_GUI(&numCPUs);
+
+    //allocate space for the variables
+    FREQ = (double *) malloc (sizeof (double) * numCPUs);
+    MULT = (double *) malloc (sizeof (double) * numCPUs);
+    C0_TIME = (long double *) malloc (sizeof (long double) * numCPUs);
+    C1_TIME = (long double *) malloc (sizeof (long double) * numCPUs);
+    C3_TIME = (long double *) malloc (sizeof (long double) * numCPUs);
+    C6_TIME = (long double *) malloc (sizeof (long double) * numCPUs);
+
+    int i;
+    for (i = 0; i < (int)numCPUs; i++)
+    {
+        FREQ[i] = 0;
+        MULT[i] = 0;
+        C0_TIME[i] = 0;
+        C1_TIME[i] = 0;
+        C3_TIME[i] = 0;
+        C6_TIME[i] = 0;
+    }
+}
+
+
+void
+MyThread::run ()
+{
+
+	print_CPU_Heirarchy(chi);
+
+    int i, ii;
+
+    //MSR number and hi:low bit of that MSR
+    //This msr contains a lot of stuff, per socket wise
+    //one can pass any core number and then get in multiplier etc
+    int PLATFORM_INFO_MSR = 206;	//CE 15:8
+    int PLATFORM_INFO_MSR_low = 8;
+    int PLATFORM_INFO_MSR_high = 15;
+
+    ////To find out if Turbo is enabled use the below msr and bit 38
+    ////bit for TURBO is 38
+    ////msr reading is now moved into tubo_status
+    //int IA32_MISC_ENABLE = 416;
+    //int TURBO_FLAG_low = 38;
+    //int TURBO_FLAG_high = 38;
+
+
+    //int MSR_TURBO_RATIO_LIMIT = 429;
+
+    int CPU_NUM;
+    int CPU_Multiplier;
+    float BLCK;
+    char TURBO_MODE;
+
+    printf("i7z DEBUG: GUI VERSION DOESN'T SUPPORT CORE OFFLINING\n");
+    sleep (1);
+
+    // 3B defines till Max 4 Core and the rest bit values from 32:63 were reserved.
+    // int MAX_TURBO_1C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 7, 0);
+    // int MAX_TURBO_2C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 15, 8);
+    // int MAX_TURBO_3C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 23, 16);
+    // int MAX_TURBO_4C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 31, 24);
+
+
+    //CPUINFO is wrong for i7 but correct for the number of physical and logical cores present
+    //If Hyperthreading is enabled then, multiple logical processors will share a common CORE ID
+    //http://www.redhat.com/magazine/022aug06/departments/tips_tricks/
+    system ("cat /proc/cpuinfo |grep MHz|sed 's/cpu\\sMHz\\s*:\\s//'|tail -n 1 > /tmp/cpufreq.txt");
+    system ("grep \"core id\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numPhysical.txt");
+    system ("grep \"processor\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numLogical.txt");
+
+
+    //Open the parsed cpufreq file and obtain the cpufreq from /proc/cpuinfo
+    FILE *tmp_file;
+    tmp_file = fopen ("/tmp/cpufreq.txt", "r");
+    char tmp_str[30];
+    fgets (tmp_str, 30, tmp_file);
+    double cpu_freq_cpuinfo = atof (tmp_str);
+    fclose (tmp_file);
+
+    unsigned int numPhysicalCores, numLogicalCores;
+    numPhysicalCores = socket_0.num_physical_cores + socket_1.num_physical_cores;
+    numLogicalCores  = socket_0.num_logical_cores + socket_1.num_logical_cores;
+//    printf("My thread: Num Processors %d\n",numCPUs);
+
+    int error_indx;
+
+    //estimate the freq using the estimate_MHz() code that is almost mhz accurate
+    cpu_freq_cpuinfo = estimate_MHz ();
+
+    //We just need one CPU (we use Core-0) to figure out the multiplier and the bus clock freq.
+    CPU_NUM = 0;
+    CPU_Multiplier =
+        get_msr_value (CPU_NUM, PLATFORM_INFO_MSR, PLATFORM_INFO_MSR_high,
+                       PLATFORM_INFO_MSR_low, &error_indx);
+    BLCK = cpu_freq_cpuinfo / CPU_Multiplier;
+    TURBO_MODE = turbo_status ();	//get_msr_value(CPU_NUM,IA32_MISC_ENABLE, TURBO_FLAG_high,TURBO_FLAG_low);
+
+    //to find how many cpus are enabled, we could have used sysconf but that will just give the logical numbers
+    //if HT is enabled then the threads of the same core have the same C-state residency number so...
+    //Its imperative to figure out the number of physical and number of logical cores.
+    //sysconf(_SC_NPROCESSORS_ONLN);
+
+
+    bool HT_ON;
+    char HT_ON_str[30];
+    if (numLogicalCores > numPhysicalCores)
+    {
+        strcpy (HT_ON_str, "Hyper Threading ON");
+        HT_ON = true;
+    }
+    else
+    {
+        strcpy (HT_ON_str, "Hyper Threading OFF");
+        HT_ON = false;
+    }
+
+    float TRUE_CPU_FREQ;
+    if (TURBO_MODE == 1)
+    {
+        TRUE_CPU_FREQ = BLCK * ((double)CPU_Multiplier + 1);
+    }
+    else
+    {
+        TRUE_CPU_FREQ = BLCK * ((double)CPU_Multiplier);
+    }
+
+
+    int IA32_PERF_GLOBAL_CTRL = 911;	//3BF
+    int IA32_PERF_GLOBAL_CTRL_Value =
+        get_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 63, 0,&error_indx);
+    int IA32_FIXED_CTR_CTL = 909;	//38D
+    int IA32_FIXED_CTR_CTL_Value =
+        get_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 63, 0,&error_indx);
+
+    //printf("IA32_PERF_GLOBAL_CTRL %d\n",IA32_PERF_GLOBAL_CTRL_Value);
+    //printf("IA32_FIXED_CTR_CTL %d\n",IA32_FIXED_CTR_CTL_Value);
+
+    unsigned long long int CPU_CLK_UNHALTED_CORE, CPU_CLK_UNHALTED_REF,
+    CPU_CLK_C3, CPU_CLK_C6, CPU_CLK_C1;
+
+    CPU_CLK_UNHALTED_CORE = get_msr_value (CPU_NUM, 778, 63, 0,&error_indx);
+    CPU_CLK_UNHALTED_REF = get_msr_value (CPU_NUM, 779, 63, 0,&error_indx);
+
+    unsigned long long int old_val_CORE[numCPUs], new_val_CORE[numCPUs];
+    unsigned long long int old_val_REF[numCPUs], new_val_REF[numCPUs];
+    unsigned long long int old_val_C3[numCPUs], new_val_C3[numCPUs];
+    unsigned long long int old_val_C6[numCPUs], new_val_C6[numCPUs];
+//  unsigned long int old_val_C1[numCPUs], new_val_C1[numCPUs];
+
+    unsigned long long int old_TSC[numCPUs], new_TSC[numCPUs];
+
+    struct timeval tvstart[numCPUs], tvstop[numCPUs];
+
+    struct timespec one_second_sleep;
+    one_second_sleep.tv_sec = 0;
+    one_second_sleep.tv_nsec = 999999999;	// 1000msec
+
+
+    unsigned long int IA32_MPERF = get_msr_value (CPU_NUM, 231, 7, 0,&error_indx);
+    unsigned long int IA32_APERF = get_msr_value (CPU_NUM, 232, 7, 0,&error_indx);
+//   mvprintw(12,0,"Wait...\n"); refresh();
+    nanosleep (&one_second_sleep, NULL);
+    IA32_MPERF = get_msr_value (CPU_NUM, 231, 7, 0, &error_indx) - IA32_MPERF;
+    IA32_APERF = get_msr_value (CPU_NUM, 232, 7, 0, &error_indx) - IA32_APERF;
+
+    //printf("Diff. i n APERF = %u, MPERF = %d\n", IA32_MPERF, IA32_APERF);
+
+    long double C0_time[numCPUs], C1_time[numCPUs], C3_time[numCPUs],    C6_time[numCPUs];
+    double _FREQ[numCPUs], _MULT[numCPUs];
+
+//  mvprintw(12,0,"Current Freqs\n");
+
+    int kk=11;
+    double estimated_mhz;
+    for (;;)
+    {
+        Construct_Socket_Information_in_GUI(&numCPUs);
+
+        if (kk>10) {
+            kk=0;
+            for (ii = 0; ii < (int)numCPUs; ii++)
+            {
+                CPU_NUM = core_list[ii];
+                IA32_PERF_GLOBAL_CTRL_Value =	get_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 63, 0, &error_indx);
+                set_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 0x700000003LLU);
+
+                IA32_FIXED_CTR_CTL_Value = get_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 63, 0, &error_indx);
+                set_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 819);
+
+                IA32_PERF_GLOBAL_CTRL_Value =	get_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 63, 0, &error_indx);
+                IA32_FIXED_CTR_CTL_Value = get_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 63, 0, &error_indx);
+
+                old_val_CORE[ii] = get_msr_value (CPU_NUM, 778, 63, 0,&error_indx);
+                old_val_REF[ii] = get_msr_value (CPU_NUM, 779, 63, 0,&error_indx);
+                old_val_C3[ii] = get_msr_value (CPU_NUM, 1020, 63, 0,&error_indx);
+                old_val_C6[ii] = get_msr_value (CPU_NUM, 1021, 63, 0,&error_indx);
+                old_TSC[ii] = rdtsc ();
+            }
+        }
+        kk++;
+
+        nanosleep (&one_second_sleep, NULL);
+
+        estimated_mhz = estimate_MHz();
+
+        for (i = 0; i < (int)numCPUs; i++)
+        {
+            CPU_NUM = core_list[i];
+            new_val_CORE[i] = get_msr_value (CPU_NUM, 778, 63, 0,&error_indx);
+            new_val_REF[i] = get_msr_value (CPU_NUM, 779, 63, 0,&error_indx);
+            new_val_C3[i] = get_msr_value (CPU_NUM, 1020, 63, 0,&error_indx);
+            new_val_C6[i] = get_msr_value (CPU_NUM, 1021, 63, 0,&error_indx);
+            new_TSC[i] = rdtsc ();
+            if (old_val_CORE[i] > new_val_CORE[i])
+            {
+                CPU_CLK_UNHALTED_CORE =
+                    (3.40282366921e38 - old_val_CORE[i]) + new_val_CORE[i];
+            }
+            else
+            {
+                CPU_CLK_UNHALTED_CORE = new_val_CORE[i] - old_val_CORE[i];
+            }
+
+            //number of TSC cycles while its in halted state
+            if ((new_TSC[i] - old_TSC[i]) < CPU_CLK_UNHALTED_CORE)
+                CPU_CLK_C1 = 0;
+            else
+                CPU_CLK_C1 = ((new_TSC[i] - old_TSC[i]) - CPU_CLK_UNHALTED_CORE);
+
+            if (old_val_REF[i] > new_val_REF[i])
+            {
+                CPU_CLK_UNHALTED_REF =
+                    (3.40282366921e38 - old_val_REF[i]) + new_val_REF[i];
+            }
+            else
+            {
+                CPU_CLK_UNHALTED_REF = new_val_REF[i] - old_val_REF[i];
+            }
+
+            if (old_val_C3[i] > new_val_C3[i])
+            {
+                CPU_CLK_C3 = (3.40282366921e38 - old_val_C3[i]) + new_val_C3[i];
+            }
+            else
+            {
+                CPU_CLK_C3 = new_val_C3[i] - old_val_C3[i];
+            }
+
+            if (old_val_C6[i] > new_val_C6[i])
+            {
+                CPU_CLK_C6 = (3.40282366921e38 - old_val_C6[i]) + new_val_C6[i];
+            }
+            else
+            {
+                CPU_CLK_C6 = new_val_C6[i] - old_val_C6[i];
+            }
+
+            _FREQ[i] =
+                estimated_mhz * ((long double) CPU_CLK_UNHALTED_CORE /
+                                 (long double) CPU_CLK_UNHALTED_REF);
+            _MULT[i] = _FREQ[i] / BLCK;
+
+            C0_time[i] =
+                ((long double) CPU_CLK_UNHALTED_REF /
+                 (long double) (new_TSC[i] - old_TSC[i]));
+            long double c1_time =
+                ((long double) CPU_CLK_C1 /
+                 (long double) (new_TSC[i] - old_TSC[i]));
+            C3_time[i] =
+                ((long double) CPU_CLK_C3 /
+                 (long double) (new_TSC[i] - old_TSC[i]));
+            C6_time[i] =
+                ((long double) CPU_CLK_C6 /
+                 (long double) (new_TSC[i] - old_TSC[i]));
+
+            //C1_time[i] -= C3_time[i] + C6_time[i];
+			C1_time[i] = c1_time - (C3_time[i] + C6_time[i]) ;
+            if (!isnan(c1_time) && !isinf(c1_time)) {
+                if (C1_time[i] <= 0) {
+                    C1_time[i]=0;
+                }
+            }
+
+            if (C0_time[i] < 1e-2) {
+                if (C0_time[i] > 1e-4) 	C0_time[i] = 0.01;
+                else				    C0_time[i] = 0;
+            }
+
+            if (C1_time[i] < 1e-2) {
+                if (C1_time[i] > 1e-4)  C1_time[i] = 0.01;
+                else				    C1_time[i] = 0;
+            }
+
+            if (C3_time[i] < 1e-2) {
+                if (C3_time[i] > 1e-4)  C3_time[i] = 0.01;
+                else			        C3_time[i] = 0;
+            }
+
+            if (C6_time[i] < 1e-2) {
+                if (C6_time[i] > 1e-4)  C6_time[i] = 0.01;
+                else			        C6_time[i] = 0;
+            }
+        }
+//   printf("Hello");
+//   for(i=0;i<numCPUs;i++){
+//      printf("%g %Lg %Lg %Lg %Lg %lld %llu\n",_FREQ[i],C0_time[i]*100,C1_time[i]*100,C3_time[i]*100,C6_time[i]*100,CPU_CLK_UNHALTED_REF,(new_TSC[i] - old_TSC[i]));
+//      printf("%g %llu %llu %llu %llu %llu\n",_FREQ[i],CPU_CLK_UNHALTED_REF,CPU_CLK_C1,CPU_CLK_C3,CPU_CLK_C6,(new_TSC[i] - old_TSC[i]));
+//      printf("%llu %llu  %lld\n",new_TSC[i], old_TSC[i],new_TSC[i]- old_TSC[i]);
+//   }
+        TRUE_CPU_FREQ = 0;
+        for (i = 0; i < (int)numCPUs; i++)
+            if (_FREQ[i] > TRUE_CPU_FREQ)
+                TRUE_CPU_FREQ = _FREQ[i];
+
+        memcpy (old_val_CORE, new_val_CORE, sizeof (unsigned long int) * numCPUs);
+        memcpy (old_val_REF, new_val_REF, sizeof (unsigned long int) * numCPUs);
+        memcpy (old_val_C3, new_val_C3, sizeof (unsigned long int) * numCPUs);
+        memcpy (old_val_C6, new_val_C6, sizeof (unsigned long int) * numCPUs);
+        memcpy (tvstart, tvstop, sizeof (struct timeval) * numCPUs);
+        memcpy (old_TSC, new_TSC, sizeof (unsigned long long int) * numCPUs);
+
+        memcpy (FREQ, _FREQ, sizeof (double) * numCPUs);
+        memcpy (MULT, _MULT, sizeof (double) * numCPUs);
+        memcpy (C0_TIME, C0_time, sizeof (long double) * numCPUs);
+        memcpy (C1_TIME, C1_time, sizeof (long double) * numCPUs);
+        memcpy (C3_TIME, C3_time, sizeof (long double) * numCPUs);
+        memcpy (C6_TIME, C6_time, sizeof (long double) * numCPUs);
+        global_in_i7z_main_thread = true;
+    }
+
+}
+
+class MyWidget:public QWidget
+{
+Q_OBJECT public:
+    QProgressBar * C0_l[MAX_PROCESSORS_GUI], *C1_l[MAX_PROCESSORS_GUI], *C3_l[MAX_PROCESSORS_GUI], *C6_l[MAX_PROCESSORS_GUI];
+    QLabel *C0, *C1, *C3, *C6;
+    QLabel *Freq_[MAX_PROCESSORS_GUI];
+    QLabel *StatusMessage0, *StatusMessage1, *Curr_Freq0, *Curr_Freq1;
+    QLabel *ProcNames[MAX_PROCESSORS_GUI];
+    MyWidget (QWidget * parent = 0);
+    MyThread *mythread;
+    int curr_numCPUs;
+
+private slots:
+    void UpdateWidget ();
+};
+
+MyWidget::MyWidget (QWidget * parent):QWidget (parent)
+{
+
+    Print_Version_Information();
+
+    //
+    //Print_Information_Processor ();
+    bool cpuNehalem, cpuSandybridge;
+    Print_Information_Processor (&cpuNehalem, &cpuSandybridge);
+
+    Test_Or_Make_MSR_DEVICE_FILES ();
+
+    Construct_Socket_Information_in_GUI(&numCPUs);
+
+    char processor_str[100];
+//    printf("MyWidget: Num Processors %d\n",numCPUs);
+    int  i;
+
+    for (i = 0; i < (int)numCPUs; i++)
+    {
+        C0_l[i] = new QProgressBar;
+        C0_l[i]->setMaximum (99);
+        C0_l[i]->setMinimum (0);
+        C1_l[i] = new QProgressBar;
+        C1_l[i]->setMaximum (99);
+        C1_l[i]->setMinimum (0);
+        C3_l[i] = new QProgressBar;
+        C3_l[i]->setMaximum (99);
+        C3_l[i]->setMinimum (0);
+        C6_l[i] = new QProgressBar;
+        C6_l[i]->setMaximum (99);
+        C6_l[i]->setMinimum (0);
+        Freq_[i] = new QLabel (tr (""));
+    }
+
+    QGridLayout * layout1 = new QGridLayout;
+
+    curr_numCPUs = numCPUs;
+    for (i = 0; i < (int)numCPUs; i++)
+    {
+        layout1->addWidget (C0_l[i], i + 1, 1);
+        layout1->addWidget (C1_l[i], i + 1, 2);
+        layout1->addWidget (C3_l[i], i + 1, 3);
+        layout1->addWidget (C6_l[i], i + 1, 4);
+    }
+
+    C0 = new QLabel (tr ("C0"));
+    C0->setAlignment (Qt::AlignCenter);
+    C1 = new QLabel (tr ("C1"));
+    C1->setAlignment (Qt::AlignCenter);
+    C3 = new QLabel (tr ("C3"));
+    C3->setAlignment (Qt::AlignCenter);
+    C6 = new QLabel (tr ("C6"));
+    C6->setAlignment (Qt::AlignCenter);
+
+    snprintf(processor_str, 100, "Core-1 [id:%d,socket:%d]",core_list[0],socket_list[0]);
+    ProcNames[0] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-2 [id:%d,socket:%d]",core_list[1],socket_list[1]);
+    ProcNames[1] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-3 [id:%d,socket:%d]",core_list[2],socket_list[2]);
+    ProcNames[2] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-4 [id:%d,socket:%d]",core_list[3],socket_list[3]);
+    ProcNames[3] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-5 [id:%d,socket:%d]",core_list[4],socket_list[4]);
+    ProcNames[4] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-6 [id:%d,socket:%d]",core_list[5],socket_list[5]);
+    ProcNames[5] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-7 [id:%d,socket:%d]",core_list[6],socket_list[6]);
+    ProcNames[6] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-8 [id:%d,socket:%d]",core_list[7],socket_list[7]);
+    ProcNames[7] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-9 [id:%d,socket:%d]",core_list[8],socket_list[8]);
+    ProcNames[8] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-10 [id:%d,socket:%d]",core_list[9],socket_list[9]);
+    ProcNames[9] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-11 [id:%d,socket:%d]",core_list[10],socket_list[10]);
+    ProcNames[10] = new QLabel (tr (processor_str));
+
+    snprintf(processor_str, 100, "Core-12 [id:%d,socket:%d]",core_list[11],socket_list[11]);
+    ProcNames[11] = new QLabel (tr (processor_str));
+
+    StatusMessage0 = new QLabel (tr ("Wait"));
+    Curr_Freq0 = new QLabel (tr ("Wait"));
+
+    if ( (socket_0.num_physical_cores > 0) && (socket_1.num_physical_cores > 0)) {
+        StatusMessage1 = new QLabel (tr ("Wait"));
+        Curr_Freq1 = new QLabel (tr ("Wait"));
+    }
+
+    for (i = 0; i < (int)numCPUs; i++) {
+        layout1->addWidget (ProcNames[i], i + 1, 0);
+    }
+
+    layout1->addWidget (C0, 0, 1);
+    layout1->addWidget (C1, 0, 2);
+    layout1->addWidget (C3, 0, 3);
+    layout1->addWidget (C6, 0, 4);
+
+    for (i = 0; i < (int)numCPUs; i++)
+        layout1->addWidget (Freq_[i], i + 1, 5);
+
+    layout1->addWidget (StatusMessage0, numCPUs + 1, 4);
+    layout1->addWidget (Curr_Freq0, numCPUs + 1, 5);
+    if ( (socket_0.num_physical_cores > 0) && (socket_1.num_physical_cores > 0)) {
+        layout1->addWidget (StatusMessage1, numCPUs + 2, 4);
+        layout1->addWidget (Curr_Freq1, numCPUs + 2, 5);
+    }
+    QTimer *timer = new QTimer (this);
+    connect (timer, SIGNAL (timeout ()), this, SLOT (UpdateWidget ()));
+    timer->start (1000);
+
+    mythread = new MyThread ();
+    mythread->start ();
+
+    setLayout (layout1);
+}
+
+void
+MyWidget::UpdateWidget ()
+{
+    char processor_str[100];
+    snprintf(processor_str, 100, "Core-1 [id:%d,socket:%d]",core_list[0],socket_list[0]);
+    ProcNames[0]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-2 [id:%d,socket:%d]",core_list[1],socket_list[1]);
+    ProcNames[1]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-3 [id:%d,socket:%d]",core_list[2],socket_list[2]);
+    ProcNames[2]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-4 [id:%d,socket:%d]",core_list[3],socket_list[3]);
+    ProcNames[3]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-5 [id:%d,socket:%d]",core_list[4],socket_list[4]);
+    ProcNames[4]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-6 [id:%d,socket:%d]",core_list[5],socket_list[5]);
+    ProcNames[5]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-7 [id:%d,socket:%d]",core_list[6],socket_list[6]);
+    ProcNames[6]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-8 [id:%d,socket:%d]",core_list[7],socket_list[7]);
+    ProcNames[7]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-9 [id:%d,socket:%d]",core_list[8],socket_list[8]);
+    ProcNames[8]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-10 [id:%d,socket:%d]",core_list[9],socket_list[9]);
+    ProcNames[9]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-11 [id:%d,socket:%d]",core_list[10],socket_list[10]);
+    ProcNames[10]->setText(tr (processor_str));
+    snprintf(processor_str, 100, "Core-12 [id:%d,socket:%d]",core_list[11],socket_list[11]);
+    ProcNames[11]->setText(tr (processor_str));
+
+//Have to make sure that the constructor is being called correct.
+//the below code logic is that if a core goes offline, call the constructor
+//so as to replot all the widgets.
+    /*    printf("Number of Cores %d\n",numCPUs);
+    	if(numCPUs != curr_numCPUs){
+    		curr_numCPUs = numCPUs;
+    		printf("Number of Cores changed\n");
+    		MyWidget (0);
+    	}*/
+
+//    printf("UpdateWidget: Num Processors %d\n",numCPUs);
+    int i;
+    char val2set[100];
+    for (i = 0; i < (int)numCPUs; i++)
+    {
+        snprintf (val2set, 100, "%0.2f Mhz", mythread->FREQ[i]);
+        Freq_[i]->setText (val2set);
+    }
+
+    for (i = 0; i < (int)numCPUs; i++)
+    {
+        C0_l[i]->setValue (mythread->C0_TIME[i] * 100);
+        C1_l[i]->setValue (mythread->C1_TIME[i] * 100);
+        C3_l[i]->setValue (mythread->C3_TIME[i] * 100);
+        C6_l[i]->setValue (mythread->C6_TIME[i] * 100);
+    }
+
+    float Max_Freq_socket0 = 0;
+    float Max_Freq_socket1 = 0;
+    int num_socket0_cpus, num_socket1_cpus;
+
+    for (i = 0; i < (int)numCPUs; i++)
+    {
+        if ( (mythread->FREQ[i] > Max_Freq_socket0) && (!isnan(mythread->FREQ[i])) &&
+                (!isinf(mythread->FREQ[i]))  && (socket_list[i] == socket_0.socket_num) ) {
+            Max_Freq_socket0 = mythread->FREQ[i];
+            num_socket0_cpus++;
+        }
+        if ( (mythread->FREQ[i] > Max_Freq_socket1) && (!isnan(mythread->FREQ[i])) &&
+                (!isinf(mythread->FREQ[i]))  && (socket_list[i] == socket_1.socket_num) ) {
+            Max_Freq_socket1 = mythread->FREQ[i];
+            num_socket1_cpus++;
+        }
+    }
+    if (socket_0.num_physical_cores > 0) {
+        StatusMessage0->setText ("Socket[0] Freq:");
+        snprintf (val2set, 100, "%0.2f Mhz", Max_Freq_socket0);
+        Curr_Freq0->setText (val2set);
+    }
+    if (socket_1.num_physical_cores > 0) {
+        StatusMessage1->setText ("Socket[1] Freq:");
+        snprintf (val2set, 100, "%0.2f Mhz", Max_Freq_socket1);
+        Curr_Freq1->setText (val2set);
+    }
+}
+
+
+
+int
+main (int argc, char *argv[])
+{
+	char hostname[1024];
+	hostname[1023] = '\0';
+	gethostname(hostname, 1023);
+    
+	QApplication app (argc, argv);
+	
+	char str_display[1050];
+	snprintf(str_display, 1050, "i7z @ %s", hostname);
+        MyWidget i7z_widget;
+	i7z_widget.setWindowTitle(str_display);
+	i7z_widget.show ();
+	return app.exec ();
+}
+
+#include "i7z_GUI.moc"

=== added file '.pc/fix-insecure-tempfile.patch/helper_functions.c'
--- .pc/fix-insecure-tempfile.patch/helper_functions.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-insecure-tempfile.patch/helper_functions.c	2013-08-15 05:58:18 +0000
@@ -0,0 +1,753 @@
+/* This  file is modified from source available at http://www.kernel.org/pub/linux/utils/cpu/msr-tools/
+ for Model specific cpu registers
+ Modified to take i7 into account by Abhishek Jaiantilal [e-mail]
+
+// Information about i7's MSR in
+// http://download.intel.com/design/processor/applnots/320354.pdf
+// Appendix B of http://www.intel.com/Assets/PDF/manual/253669.pdf
+
+//about rdmsr
+#ident "$Id: rdmsr.c,v 1.4 2004/07/20 15:54:59 hpa Exp $"
+ ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2000 Transmeta Corporation - All Rights Reserved
+ *
+ *   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, Inc., 51 Franklin St, Fifth Floor,
+ *   Boston, MA 02110-1301, USA; 
+ *   either version 2 of the License, or (at your option) any later
+ *   version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+#include <memory.h>
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <time.h>
+#include <assert.h>
+#include <math.h>
+#include "i7z.h"
+
+//#define ULLONG_MAX 18446744073709551615
+
+extern struct program_options prog_options;
+bool E7_mp_present=false;
+
+/////////////////////////////////////////READ TEMPERATURE////////////////////////////////////////////
+#define IA32_THERM_STATUS 0x19C
+#define IA32_TEMPERATURE_TARGET 0x1a2
+#define IA32_PACKAGE_THERM_STATUS 0x1b1
+
+int Get_Bits_Value(unsigned long val,int highbit, int lowbit){ 
+	unsigned long data = val;
+	int bits = highbit - lowbit + 1;
+	if(bits<64){
+	    data >>= lowbit;
+	    data &= (1ULL<<bits) - 1;
+	}
+	return(data);
+}
+
+// a nice document to read is 322683.pdf from intel
+int Read_Thermal_Status_CPU(int cpu_num){
+	int error_indx;
+	unsigned long val= get_msr_value(cpu_num,IA32_THERM_STATUS,63,0,&error_indx);
+	int digital_readout = Get_Bits_Value(val,23,16);
+	bool thermal_status = Get_Bits_Value(val,32,31);
+
+        val= get_msr_value(cpu_num,IA32_TEMPERATURE_TARGET,63,0,&error_indx);
+        int PROCHOT_temp = Get_Bits_Value(val,23,16);
+    
+	//temperature is prochot - digital readout
+	if (thermal_status)
+	  return(PROCHOT_temp - digital_readout);
+	else
+	  return(-1);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+void
+print_family_info (struct family_info *proc_info)
+{
+    //print CPU info
+    printf ("i7z DEBUG:    Stepping %x\n", proc_info->stepping);
+    printf ("i7z DEBUG:    Model %x\n", proc_info->model);
+    printf ("i7z DEBUG:    Family %x\n", proc_info->family);
+    printf ("i7z DEBUG:    Processor Type %x\n", proc_info->processor_type);
+    printf ("i7z DEBUG:    Extended Model %x\n", proc_info->extended_model);
+    //    printf("    Extended Family %x\n", (short int*)(&proc_info->extended_family));
+    //    printf("    Extended Family %d\n", proc_info->extended_family);
+}
+
+static inline void cpuid (unsigned int info, unsigned int *eax, unsigned int *ebx,
+                          unsigned int *ecx, unsigned int *edx)
+{
+    unsigned int _eax = info, _ebx, _ecx, _edx;
+    asm volatile ("mov %%ebx, %%edi;" // save ebx (for PIC)
+                  "cpuid;"
+                  "mov %%ebx, %%esi;" // pass to caller
+                  "mov %%edi, %%ebx;" // restore ebx
+                  :"+a" (_eax), "=S" (_ebx), "=c" (_ecx), "=d" (_edx)
+                  :      /* inputs: eax is handled above */
+                  :"edi" /* clobbers: we hit edi directly */);
+    if (eax) *eax = _eax;
+    if (ebx) *ebx = _ebx;
+    if (ecx) *ecx = _ecx;
+    if (edx) *edx = _edx;
+}
+
+static inline void  get_vendor (char *vendor_string)
+{
+    //get vendor name
+    unsigned int a, b, c, d;
+    cpuid (0, &a, &b, &c, &d);
+    memcpy (vendor_string, &b, 4);
+    memcpy (&vendor_string[4], &d, 4);
+    memcpy (&vendor_string[8], &c, 4);
+    vendor_string[12] = '\0';
+    //        printf("Vendor %s\n",vendor_string);
+}
+
+int turbo_status ()
+{
+    //turbo state flag
+    unsigned int eax;
+    cpuid (6, &eax, NULL, NULL, NULL);
+
+    //printf("eax %d\n",(eax&0x2)>>1);
+
+    return ((eax & 0x2) >> 1);
+}
+
+static inline void get_familyinformation (struct family_info *proc_info)
+{
+    //get info about CPU
+    unsigned int b;
+    cpuid (1, &b, NULL, NULL, NULL);
+    //  printf ("eax %x\n", b);
+    proc_info->stepping = b & 0x0000000F;	//bits 3:0
+    proc_info->model = (b & 0x000000F0) >> 4;	//bits 7:4
+    proc_info->family = (b & 0x00000F00) >> 8;	//bits 11:8
+    proc_info->processor_type = (b & 0x00007000) >> 12;	//bits 13:12
+    proc_info->extended_model = (b & 0x000F0000) >> 16;	//bits 19:16
+    proc_info->extended_family = (b & 0x0FF00000) >> 20;	//bits 27:20
+}
+
+double estimate_MHz ()
+{
+    //copied blantantly from http://www.cs.helsinki.fi/linux/linux-kernel/2001-37/0256.html
+    /*
+    * $Id: MHz.c,v 1.4 2001/05/21 18:58:01 davej Exp $
+    * This file is part of x86info.
+    * (C) 2001 Dave Jones.
+    *
+    * Licensed under the terms of the GNU GPL License version 2.
+    *
+    * Estimate CPU MHz routine by Andrea Arcangeli <[e-mail]>
+    * Small changes by David Sterba <[e-mail]>
+    *
+    */
+    struct timezone tz;
+    struct timeval tvstart, tvstop;
+    unsigned long long int cycles[2];	/* gotta be 64 bit */
+    unsigned long long int microseconds;	/* total time taken */
+
+    memset (&tz, 0, sizeof (tz));
+
+    /* get this function in cached memory */
+    gettimeofday (&tvstart, &tz);
+    cycles[0] = rdtsc ();
+    gettimeofday (&tvstart, &tz);
+
+    /* we don't trust that this is any specific length of time */
+    //1 sec will cause rdtsc to overlap multiple times perhaps. 100msecs is a good spot
+    usleep (10000);
+
+    cycles[1] = rdtsc ();
+    gettimeofday (&tvstop, &tz);
+    microseconds = ((tvstop.tv_sec - tvstart.tv_sec) * 1000000) +
+                   (tvstop.tv_usec - tvstart.tv_usec);
+
+    unsigned long long int elapsed = 0;
+    if (cycles[1] < cycles[0])
+    {
+        //printf("c0 = %llu   c1 = %llu",cycles[0],cycles[1]);
+        elapsed = UINT32_MAX - cycles[0];
+        elapsed = elapsed + cycles[1];
+        //printf("c0 = %llu  c1 = %llu max = %llu elapsed=%llu\n",cycles[0], cycles[1], UINT32_MAX,elapsed);
+    }
+    else
+    {
+        elapsed = cycles[1] - cycles[0];
+        //printf("\nc0 = %llu  c1 = %llu elapsed=%llu\n",cycles[0], cycles[1],elapsed);
+    }
+
+    double mhz = elapsed / microseconds;
+
+
+    //printf("%llg MHz processor (estimate).  diff cycles=%llu  microseconds=%llu \n", mhz, elapsed, microseconds);
+    //printf("%g  elapsed %llu  microseconds %llu\n",mhz, elapsed, microseconds);
+    return (mhz);
+}
+
+/* Number of decimal digits for a certain number of bits */
+/* (int) ceil(log(2^n)/log(10)) */
+int decdigits[] = {
+    1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5,
+    5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10,
+    10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15,
+    15, 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19,
+    20
+};
+
+#define mo_hex  0x01
+#define mo_dec  0x02
+#define mo_oct  0x03
+#define mo_raw  0x04
+#define mo_uns  0x05
+#define mo_chx  0x06
+#define mo_mask 0x0f
+#define mo_fill 0x40
+#define mo_c    0x80
+
+const char *program;
+
+
+uint64_t get_msr_value (int cpu, uint32_t reg, unsigned int highbit,
+                        unsigned int lowbit, int* error_indx)
+{
+    uint64_t data;
+    int fd;
+    //  char *pat;
+    //  int width;
+    char msr_file_name[64];
+    int bits;
+    *error_indx =0;
+
+    sprintf (msr_file_name, "/dev/cpu/%d/msr", cpu);
+    fd = open (msr_file_name, O_RDONLY);
+    if (fd < 0)
+    {
+        if (errno == ENXIO)
+        {
+            //fprintf (stderr, "rdmsr: No CPU %d\n", cpu);
+            *error_indx = 1;
+            return 1;
+        } else if (errno == EIO) {
+            //fprintf (stderr, "rdmsr: CPU %d doesn't support MSRs\n", cpu);
+            *error_indx = 1;
+            return 1;
+        } else {
+            //perror ("rdmsr:open");
+            *error_indx = 1;
+            return 1;
+            //exit (127);
+        }
+    }
+
+    if (pread (fd, &data, sizeof data, reg) != sizeof data)
+    {
+        perror ("rdmsr:pread");
+        exit (127);
+    }
+
+    close (fd);
+
+    bits = highbit - lowbit + 1;
+    if (bits < 64)
+    {
+        /* Show only part of register */
+        data >>= lowbit;
+        data &= (1ULL << bits) - 1;
+    }
+
+    /* Make sure we get sign correct */
+    if (data & (1ULL << (bits - 1)))
+    {
+        data &= ~(1ULL << (bits - 1));
+        data = -data;
+    }
+
+    *error_indx = 0;
+    return (data);
+}
+
+uint64_t set_msr_value (int cpu, uint32_t reg, uint64_t data)
+{
+    int fd;
+    char msr_file_name[64];
+
+    sprintf (msr_file_name, "/dev/cpu/%d/msr", cpu);
+    fd = open (msr_file_name, O_WRONLY);
+    if (fd < 0)
+    {
+        if (errno == ENXIO)
+        {
+            fprintf (stderr, "wrmsr: No CPU %d\n", cpu);
+            exit (2);
+        } else if (errno == EIO) {
+            fprintf (stderr, "wrmsr: CPU %d doesn't support MSRs\n", cpu);
+            exit (3);
+        } else {
+            perror ("wrmsr:open");
+            exit (127);
+        }
+    }
+
+    if (pwrite (fd, &data, sizeof data, reg) != sizeof data)
+    {
+        perror ("wrmsr:pwrite");
+        exit (127);
+    }
+    close(fd);
+    return(1);
+}
+
+
+#ifdef USE_INTEL_CPUID
+void get_CPUs_info (unsigned int *num_Logical_OS,
+                    unsigned int *num_Logical_process,
+                    unsigned int *num_Processor_Core,
+
+                    unsigned int *num_Physical_Socket);
+
+#endif
+
+
+//Below code
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2010 Abhishek Jaiantilal
+ *
+ *   Under GPL v2
+ *
+ * ----------------------------------------------------------------------- */
+
+void Print_Version_Information()
+{
+	printf ("i7z DEBUG: i7z version: %s\n",i7z_VERSION_INFO);
+}
+
+
+//sets whether its nehalem or sandy bridge
+void Print_Information_Processor(bool* nehalem, bool* sandy_bridge) 
+{
+    struct family_info proc_info;
+
+    char vendor_string[13];
+    memset(vendor_string,0,13);
+    
+    get_vendor (vendor_string);
+    vendor_string[12] = '\0';
+
+    //look at the blurb below for why strcmp is done byte by byte
+    /*
+    bool equal_string = true;
+    char const* genuine_intel_str = "GenuineIntel";
+    int i;
+    for(i=0; i<12;i++) {
+        if (vendor_string[i] != genuine_intel_str[i])
+            equal_string = false;
+    }
+    */
+    // somehow using strcmp or strncmp is crashing the app when using -O2, -O3 with gcc-4.7
+    // (strncmp (vendor_string, "GenuineIntel",12) == 0)
+    // (strcmp (vendor_string, "GenuineIntel",12) == 0)
+
+    if (strcmp (vendor_string, "GenuineIntel") == 0) {
+    //if (equal_string) {
+        printf ("i7z DEBUG: Found Intel Processor\n");
+    } else {
+        printf
+        ("this was designed to be a intel proc utility. You can perhaps mod it for your machine?\n");
+        exit (1);
+    }
+
+    get_familyinformation (&proc_info);
+    print_family_info (&proc_info);
+
+    //printf("%x %x",proc_info.extended_model,proc_info.family);
+
+    //check if its nehalem or exit
+    //Info from page 641 of Intel Manual 3B
+    //Extended model and Model can help determine the right cpu
+
+    //furthermore from pdf 241618.pdf from intel
+    //page 24, got the following info
+
+    //extended model is either 0x1 or 0x2
+    //check on model number as follows
+    //extended model, model no - processor type
+    //0x1, 0xA - i7, 45nm
+    //0x1, 0xE - i7, i5, Xeon, 45nm
+    //0x2, 0xE - Xeon MP, 45nm //e.g. x75xx processors
+    //0x2, 0xF - Xeon MP, 32nm //e.g. e7-48xx processors 
+    //0x2, 0xC - i7, Xeon, 32nm
+    //0x2, 0x5 - i3, i5, i7 mobile processors, 32nm
+    //0x2, 0xA - i7, 32nm
+
+    //http://ark.intel.com/SSPECQDF.aspx
+    //http://software.intel.com/en-us/articles/intel-processor-identification-with-cpuid-model-and-family-numbers/
+    printf("i7z DEBUG: msr = Model Specific Register\n");
+    if (proc_info.family >= 0x6)
+    {
+        if (proc_info.extended_model == 0x1)
+        {
+            switch (proc_info.model)
+            {
+            case 0xA:
+                printf ("i7z DEBUG: Detected a nehalem (i7) - 45nm\n");
+                break;
+            case 0xE:
+            case 0xF:
+                printf ("i7z DEBUG: Detected a nehalem (i7/i5/Xeon) - 45nm\n");
+	        break;
+            default:
+                printf ("i7z DEBUG: Unknown processor, not exactly based on Nehalem\n");
+                //exit (1);
+            }
+   	    *nehalem = true;
+	    *sandy_bridge = false;
+        } else if (proc_info.extended_model == 0x2) {
+            switch (proc_info.model)
+            {
+            case 0xE:
+                printf ("i7z DEBUG: Detected a Xeon MP - 45nm (7500, 6500 series)\n");
+		*nehalem = true;
+  	    	*sandy_bridge = false;
+                break;
+            case 0xF:
+                printf ("i7z DEBUG: Detected a Xeon MP - 32nm (E7 series)\n");
+	        *nehalem = true;
+  	        *sandy_bridge = false;
+  	        E7_mp_present = true;
+                break;
+            case 0xC:
+	        *nehalem = true;
+  	        *sandy_bridge = false;
+                printf ("i7z DEBUG: Detected an i7/Xeon - 32 nm (westmere)\n");
+                break;
+            case 0x5:
+	        *nehalem = true;
+  	        *sandy_bridge = false;
+	        printf ("i7z DEBUG: Detected an i3/i5/i7 - 32nm (westmere - 1st generation core)\n");
+	        break;
+            case 0xD:
+	        *nehalem = false;
+	  	*sandy_bridge = true;
+	        printf ("i7z DEBUG: Detected an i7 - 32nm (haven't seen this version around, do write to me with the model number)\n");
+	        break;
+            case 0xA:
+	        *nehalem = false;
+	  	*sandy_bridge = true;
+	        printf ("i7z DEBUG: Detected an i3/i5/i7 - 32nm (sandy bridge - 2nd generation core)\n");
+	        break;
+            default:
+                printf ("i7z DEBUG: Unknown processor, not exactly based on Nehalem\n");
+                printf("i7z DEBUG: detected a newer model of ivy bridge processor\n");
+                printf("i7z DEBUG: my coder doesn't know about it, can you send the following info to him?\n");
+                printf("i7z DEBUG: model %x, extended model %x, proc_family %x\n", proc_info.model, proc_info.extended_model, proc_info.family);
+                //exit (1);
+            }
+        } else if (proc_info.extended_model == 0x3) {
+            switch (proc_info.model)
+            {
+            case 0xA:
+                printf ("i7z DEBUG: Detected an ivy bridege processor\n");
+		*nehalem = false;
+  	    	*sandy_bridge = true;
+                break;
+            default:
+                printf("i7z DEBUG: detected a newer model of ivy bridge processor\n");
+                printf("i7z DEBUG: my coder doesn't know about it, can you send the following info to him?\n");
+                printf("i7z DEBUG: model %x, extended model %x, proc_family %x\n", proc_info.model, proc_info.extended_model, proc_info.family);
+                sleep(5);
+            }
+        } else {
+            printf ("i7z DEBUG: Unknown processor, not exactly based on Nehalem, Sandy bridge or Ivy Bridge\n");
+            //exit (1);
+        }
+    } else {
+        printf ("i7z DEBUG: Unknown processor, not exactly based on Nehalem\n");
+        exit (1);
+    }
+
+}
+
+void Test_Or_Make_MSR_DEVICE_FILES() 
+{
+    //test if the msr file exists
+    if (access ("/dev/cpu/0/msr", F_OK) == 0)
+    {
+        printf ("i7z DEBUG: msr device files exist /dev/cpu/*/msr\n");
+        if (access ("/dev/cpu/0/msr", W_OK) == 0)
+        {
+            //a system mght have been set with msr allowable to be written
+            //by a normal user so...
+            //Do nothing.
+            printf ("i7z DEBUG: You have write permissions to msr device files\n");
+        } else {
+            printf ("i7z DEBUG: You DONOT have write permissions to msr device files\n");
+            printf ("i7z DEBUG: A solution is to run this program as root\n");
+            exit (1);
+        }
+    } else {
+        printf ("i7z DEBUG: msr device files DONOT exist, trying out a makedev script\n");
+        if (geteuid () == 0)
+        {
+            //Try the Makedev script
+            //sourced from MAKEDEV-cpuid-msr script in msr-tools
+            system ("msr_major=202; \
+							cpuid_major=203; \
+							n=0; \
+							while [ $n -lt 16 ]; do \
+								mkdir -m 0755 -p /dev/cpu/$n; \
+								mknod /dev/cpu/$n/msr -m 0600 c $msr_major $n; \
+								mknod /dev/cpu/$n/cpuid -m 0444 c $cpuid_major $n; \
+								n=`expr $n + 1`; \
+							done; \
+							");
+            printf ("i7z DEBUG: modprobbing for msr\n");
+            system ("modprobe msr");
+        } else {
+            printf ("i7z DEBUG: You DONOT have root privileges, mknod to create device entries won't work out\n");
+            printf ("i7z DEBUG: A solution is to run this program as root\n");
+            exit (1);
+        }
+    }
+}
+double cpufreq_info()
+{
+    //CPUINFO is wrong for i7 but correct for the number of physical and logical cores present
+    //If Hyperthreading is enabled then, multiple logical processors will share a common CORE ID
+    //http://www.redhat.com/magazine/022aug06/departments/tips_tricks/
+    system
+    ("cat /proc/cpuinfo |grep MHz|sed 's/cpu\\sMHz\\s*:\\s//'|tail -n 1 > /tmp/cpufreq.txt");
+
+
+    //Open the parsed cpufreq file and obtain the cpufreq from /proc/cpuinfo
+    FILE *tmp_file;
+    tmp_file = fopen ("/tmp/cpufreq.txt", "r");
+    char tmp_str[30];
+    fgets (tmp_str, 30, tmp_file);
+    fclose (tmp_file);
+    return atof(tmp_str);
+}
+
+int check_and_return_processor(char*strinfo)
+{
+    char *t1;
+    if (strstr(strinfo,"processor") !=NULL) {
+        strtok(strinfo,":");
+        t1 = strtok(NULL, " ");
+        return(atoi(t1));
+    } else {
+        return(-1);
+    }
+}
+
+int check_and_return_physical_id(char*strinfo)
+{
+    char *t1;
+    if (strstr(strinfo,"physical id") !=NULL) {
+        strtok(strinfo,":");
+        t1 = strtok(NULL, " ");
+        return(atoi(t1));
+    } else {
+        return(-1);
+    }
+}
+
+int check_and_return_core_id(char*strinfo)
+{
+    char *t1;
+    if (strstr(strinfo,"core id") !=NULL) {
+        strtok(strinfo,":");
+        t1 = strtok(NULL, " ");
+        return(atoi(t1));
+    } else {
+        return(-1);
+    }
+}
+
+void construct_sibling_list(struct cpu_heirarchy_info* chi)
+{
+    int i,j,core_id,socket_id;
+    for (i=0;i< chi->max_online_cpu ;i++) {
+        assert(i < MAX_HI_PROCESSORS);
+        chi->sibling_num[i]=-1;
+    }
+
+    chi->HT=false;
+    for (i=0;i< chi->max_online_cpu ;i++) {
+        assert(i < MAX_HI_PROCESSORS);
+        core_id = chi->coreid_num[i];
+        socket_id = chi->package_num[i];
+        for (j=i+1;j< chi->max_online_cpu ;j++) {
+            assert(j < MAX_HI_PROCESSORS);
+            if (chi->coreid_num[j] == core_id && chi->package_num[j] == socket_id) {
+                chi->sibling_num[j] = i;
+                chi->sibling_num[i] = j;
+                chi->display_cores[i] = 1;
+                chi->display_cores[j] = -1;
+                chi->HT=true;
+                continue;
+            }
+        }
+    }
+    //for cores that donot have a sibling put in 1
+    for (i=0;i< chi->max_online_cpu ;i++) {
+        assert(i < MAX_HI_PROCESSORS);
+        if (chi->sibling_num[i] ==-1)
+            chi->display_cores[i] = 1;
+    }
+}
+
+void construct_socket_information(struct cpu_heirarchy_info* chi,
+    struct cpu_socket_info* socket_0,struct cpu_socket_info* socket_1,
+    int socket_0_num, int socket_1_num)
+{
+    int i;
+
+    socket_0->max_cpu=0;
+    socket_0->num_physical_cores=0;
+    socket_0->num_logical_cores=0;
+    socket_1->max_cpu=0;
+    socket_1->num_physical_cores=0;
+    socket_1->num_logical_cores=0;
+
+
+    for (i=0;i< chi->max_online_cpu ;i++) {
+        assert(i < MAX_HI_PROCESSORS);
+        if (chi->display_cores[i]!=-1) {
+            if (chi->package_num[i]==socket_0_num) {
+                assert(socket_0->max_cpu < MAX_SK_PROCESSORS);
+                socket_0->processor_num[socket_0->max_cpu]=chi->processor_num[i];
+                socket_0->max_cpu++;
+                socket_0->num_physical_cores++;
+                socket_0->num_logical_cores++;
+            }
+            if (chi->package_num[i]==socket_1_num) {
+                assert(socket_1->max_cpu < MAX_SK_PROCESSORS);
+                socket_1->processor_num[socket_1->max_cpu]=chi->processor_num[i];
+                socket_1->max_cpu++;
+                socket_1->num_physical_cores++;
+                socket_1->num_logical_cores++;
+            }
+        } else {
+            if (chi->package_num[i]==socket_0_num) {
+                socket_0->num_logical_cores++;
+            }
+            if (chi->package_num[i]==socket_1_num) {
+                socket_1->num_logical_cores++;
+            }
+        }
+    }
+}
+
+void print_socket_information(struct cpu_socket_info* socket)
+{
+    int i;
+    char socket_list[200]="";
+
+    for (i=0;i< socket->max_cpu ;i++) {
+        assert(i < MAX_SK_PROCESSORS);
+        if (socket->processor_num[i]!=-1) {
+            sprintf(socket_list,"%s%d,",socket_list,socket->processor_num[i]);
+        }
+    }
+    printf("Socket-%d [num of cpus %d physical %d logical %d] %s\n",socket->socket_num,socket->max_cpu,socket->num_physical_cores,socket->num_logical_cores,socket_list);
+}
+
+void construct_CPU_Heirarchy_info(struct cpu_heirarchy_info* chi)
+{
+    FILE *fp = fopen("/proc/cpuinfo","r");
+    char strinfo[200];
+
+    int processor_num, physicalid_num, coreid_num;
+    int it_processor_num=-1, it_physicalid_num=-1, it_coreid_num=-1;
+    int tmp_processor_num, tmp_physicalid_num, tmp_coreid_num;
+    int old_processor_num=-1;
+
+    memset(chi, 0, sizeof(*chi));
+
+    if (fp!=NULL) {
+        while ( fgets(strinfo,200,fp) != NULL) {
+            //		printf(strinfo);
+            tmp_processor_num = check_and_return_processor(strinfo);
+            tmp_physicalid_num = check_and_return_physical_id(strinfo);
+            tmp_coreid_num = check_and_return_core_id(strinfo);
+
+
+            if (tmp_processor_num != -1) {
+                it_processor_num++;
+                processor_num = tmp_processor_num;
+                assert(it_processor_num < MAX_HI_PROCESSORS);
+                chi->processor_num[it_processor_num] = processor_num;
+            }
+            if (tmp_physicalid_num != -1) {
+                it_physicalid_num++;
+                physicalid_num = tmp_physicalid_num;
+                assert(it_physicalid_num < MAX_HI_PROCESSORS);
+                chi->package_num[it_physicalid_num] = physicalid_num;
+            }
+            if (tmp_coreid_num != -1) {
+                it_coreid_num++;
+                coreid_num = tmp_coreid_num;
+                assert(it_coreid_num < MAX_HI_PROCESSORS);
+                chi->coreid_num[it_coreid_num] = coreid_num;
+            }
+            if (processor_num != old_processor_num) {
+                old_processor_num = processor_num;
+            }
+        }
+    }
+    chi->max_online_cpu = it_processor_num+1;
+    fclose(fp);
+}
+
+void print_CPU_Heirarchy(struct cpu_heirarchy_info chi)
+{
+    int i;
+    printf("\n------------------------------\n--[core id]--- Other information\n-------------------------------------\n");
+    for (i=0;i < chi.max_online_cpu;i++) {
+        assert(i < MAX_HI_PROCESSORS);
+        printf("--[%d] Processor number %d\n",i,chi.processor_num[i]);
+        printf("--[%d] Socket number/Hyperthreaded Sibling number  %d,%d\n",i,chi.package_num[i],chi.sibling_num[i]);
+        printf("--[%d] Core id number %d\n",i,chi.coreid_num[i]);
+        printf("--[%d] Display core in i7z Tool: %s\n\n",i,(chi.display_cores[i]==1)?"Yes":"No");
+    }
+}
+
+int in_core_list(int ii,int* core_list)
+{
+    int i;
+    int in=0;
+    for (i=0;i<8;i++) {
+        if (ii == core_list[i]) {
+            in=1;
+            break;
+        }
+    }
+    return(in);
+}
+
+bool file_exists(char* filename)
+{
+    if (access(filename, F_OK) == 0)
+    {
+        return true;
+    } else {
+        return false;
+    }
+}

=== added file '.pc/fix-insecure-tempfile.patch/i7z_Single_Socket.c'
--- .pc/fix-insecure-tempfile.patch/i7z_Single_Socket.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-insecure-tempfile.patch/i7z_Single_Socket.c	2013-08-15 05:58:18 +0000
@@ -0,0 +1,1216 @@
+//i7z_Single_Socket.c
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2010 Abhishek Jaiantilal
+ *
+ *   Under GPL v2
+ *
+ * ----------------------------------------------------------------------- */
+#include <memory.h>
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <time.h>
+#include <math.h>
+#include <assert.h>
+#include <ncurses.h>
+#include "i7z.h"
+
+#define U_L_I unsigned long int
+#define U_L_L_I unsigned long long int
+#define numCPUs_max MAX_PROCESSORS
+
+extern int socket_0_num, socket_1_num;
+extern bool E7_mp_present;
+extern int numPhysicalCores, numLogicalCores;
+extern double TRUE_CPU_FREQ;
+int Read_Thermal_Status_CPU(int cpu_num);
+
+extern struct program_options prog_options;
+extern FILE *fp_log_file_freq;
+
+struct timespec global_ts;
+
+extern char* CPU_FREQUENCY_LOGGING_FILE_single;
+extern char* CPU_FREQUENCY_LOGGING_FILE_dual;
+extern bool use_ncurses;
+
+void logCpuFreq_single_ts( struct timespec*);
+
+
+void print_i7z_socket_single(struct cpu_socket_info socket_0, int printw_offset, int PLATFORM_INFO_MSR,  int PLATFORM_INFO_MSR_high,  int PLATFORM_INFO_MSR_low,
+                             int* online_cpus, double cpu_freq_cpuinfo,  struct timespec one_second_sleep, char TURBO_MODE,
+                             char* HT_ON_str, int* kk_1, U_L_L_I * old_val_CORE, U_L_L_I * old_val_REF, U_L_L_I * old_val_C3, U_L_L_I * old_val_C6, U_L_L_I * old_val_C7,
+                             U_L_L_I * old_TSC, int estimated_mhz,  U_L_L_I * new_val_CORE,  U_L_L_I * new_val_REF,  U_L_L_I * new_val_C3,
+                             U_L_L_I * new_val_C6,  U_L_L_I * new_val_C7,  U_L_L_I * new_TSC,  double* _FREQ, double* _MULT, long double * C0_time, long double * C1_time,
+                             long double * C3_time,	long double * C6_time, long double * C7_time, struct timeval* tvstart, struct timeval* tvstop, int *max_observed_cpu);
+
+void print_i7z_single ();
+
+int Single_Socket ()
+{
+    //zero up the file before doing anything
+    if(prog_options.logging!=0){
+        fp_log_file_freq = fopen(CPU_FREQUENCY_LOGGING_FILE_single,"w");
+        fclose(fp_log_file_freq);
+    }
+    
+
+    printf ("i7z DEBUG: In i7z Single_Socket()\n");
+     
+    if (prog_options.i7_version.sandy_bridge)
+	printf ("i7z DEBUG: guessing Sandy Bridge\n");
+    else
+	printf ("i7z DEBUG: guessing Nehalem\n");
+
+
+    sleep (3);
+
+    if (use_ncurses){
+        //int row, col;             
+                                   /* to store the number of rows and    *
+                                    * the number of colums of the screen *
+                                    * for NCURSES                        */
+        //Setup stuff for ncurses
+        initscr ();			/* start the curses mode */
+        start_color ();
+        //getmaxyx (stdscr, row, col);	/* get the number of rows and columns */
+        refresh ();
+        //Setup for ncurses completed
+    }
+    print_i7z_single();
+    exit (0);
+    return (1);
+}
+
+void print_i7z_socket_single(struct cpu_socket_info socket_0, int printw_offset, int PLATFORM_INFO_MSR,  int PLATFORM_INFO_MSR_high,  int PLATFORM_INFO_MSR_low,
+                             int* online_cpus, double cpu_freq_cpuinfo,  struct timespec one_second_sleep, char TURBO_MODE,
+                             char* HT_ON_str, int* kk_1, U_L_L_I * old_val_CORE, U_L_L_I * old_val_REF, U_L_L_I * old_val_C3, U_L_L_I * old_val_C6, U_L_L_I * old_val_C7,
+                             U_L_L_I * old_TSC, int estimated_mhz,  U_L_L_I * new_val_CORE,  U_L_L_I * new_val_REF,  U_L_L_I * new_val_C3,
+                             U_L_L_I * new_val_C6,  U_L_L_I * new_val_C7,  U_L_L_I * new_TSC,  double* _FREQ, double* _MULT, long double * C0_time, long double * C1_time,
+                             long double * C3_time,	long double * C6_time, long double * C7_time, struct timeval* tvstart, struct timeval* tvstop, int *max_observed_cpu)
+{
+	int numPhysicalCores, numLogicalCores;
+	double TRUE_CPU_FREQ;
+
+    //Print a slew of information on the ncurses window
+    mvprintw (0, 0, "Cpu speed from cpuinfo %0.2fMhz\n", cpu_freq_cpuinfo);
+    mvprintw (1, 0,
+              "cpuinfo might be wrong if cpufreq is enabled. To guess correctly try estimating via tsc\n");
+    mvprintw (2, 0, "Linux's inbuilt cpu_khz code emulated now\n\n");
+
+
+    //estimate the freq using the estimate_MHz() code that is almost mhz accurate
+    cpu_freq_cpuinfo = estimate_MHz ();
+    mvprintw (3, 0, "True Frequency (without accounting Turbo) %0.0f MHz\n",
+              cpu_freq_cpuinfo);
+
+    int i, ii;
+    //int k;
+    int CPU_NUM;
+    int* core_list;
+    unsigned long int IA32_MPERF, IA32_APERF;
+    int CPU_Multiplier, error_indx;
+    unsigned long long int CPU_CLK_UNHALTED_CORE, CPU_CLK_UNHALTED_REF, CPU_CLK_C3, CPU_CLK_C6, CPU_CLK_C1, CPU_CLK_C7;
+    //current blck value
+    float BLCK;
+
+    char print_core[32];
+    long double c1_time;
+
+    //use this variable to monitor the max number of cores ever online
+    *max_observed_cpu = (socket_0.max_cpu > *max_observed_cpu)? socket_0.max_cpu: *max_observed_cpu;
+
+    int core_list_size_phy,	core_list_size_log;
+    if (socket_0.max_cpu > 0) {
+        //set the variable print_core to 0, use it to check if a core is online and doesnt
+        //have any garbage values
+        memset(print_core, 0, 6*sizeof(char));
+
+        //We just need one CPU (we use Core-1) to figure out the multiplier and the bus clock freq.
+        //multiplier doesnt automatically include turbo
+        //note turbo is not guaranteed, only promised
+        //So this msr will only reflect the actual multiplier, rest has to be figured out
+
+        //Now get all the information about the socket from the structure
+        CPU_NUM = socket_0.processor_num[0];
+        core_list = socket_0.processor_num;
+        core_list_size_phy = socket_0.num_physical_cores;
+        core_list_size_log = socket_0.num_logical_cores;
+
+        /*if (CPU_NUM == -1)
+        {
+              sleep (1);		//sleep for a bit hoping that the offline socket becomes online
+              continue;
+        }*/
+        //number of CPUs is as told via cpuinfo
+        int numCPUs = socket_0.num_physical_cores;
+
+        CPU_Multiplier = get_msr_value (CPU_NUM, PLATFORM_INFO_MSR, PLATFORM_INFO_MSR_high, PLATFORM_INFO_MSR_low, &error_indx);
+        SET_IF_TRUE(error_indx,online_cpus[0],-1);
+
+        //Blck is basically the true speed divided by the multiplier
+        BLCK = cpu_freq_cpuinfo / CPU_Multiplier;
+
+        //Use Core-1 as the one to check for the turbo limit
+        //Core number shouldnt matter
+
+        //bits from 0-63 in this store the various maximum turbo limits
+        int MSR_TURBO_RATIO_LIMIT = 429;
+        // 3B defines till Max 4 Core and the rest bit values from 32:63 were reserved.
+        int MAX_TURBO_1C=0, MAX_TURBO_2C=0, MAX_TURBO_3C=0,
+            MAX_TURBO_4C=0, MAX_TURBO_5C=0, MAX_TURBO_6C=0;
+        
+        if ( E7_mp_present){
+            //e7 mp dont have 429 register so dont read the register.
+        } else {
+            //Bits:0-7  - core1
+            MAX_TURBO_1C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 7, 0, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[0],-1);
+            //Bits:15-8 - core2
+            MAX_TURBO_2C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 15, 8, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[0],-1);
+            //Bits:23-16 - core3
+            MAX_TURBO_3C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 23, 16, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[0],-1);
+            //Bits:31-24 - core4
+            MAX_TURBO_4C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 31, 24, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[0],-1);
+
+            //gulftown/Hexacore support
+            //technically these should be the bits to get for core 5,6
+            //Bits:39-32 - core4
+            MAX_TURBO_5C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 39, 32, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[0],-1);
+            //Bits:47-40 - core4
+            MAX_TURBO_6C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 47, 40, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[0],-1);
+        }
+        //fflush (stdout);
+        //sleep (1);
+
+        char string_ptr1[200], string_ptr2[200];
+
+        int IA32_PERF_GLOBAL_CTRL = 911;	//38F
+        int IA32_PERF_GLOBAL_CTRL_Value;
+        IA32_PERF_GLOBAL_CTRL_Value =	get_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 63, 0, &error_indx);
+        SET_IF_TRUE(error_indx,online_cpus[0],-1);
+        RETURN_IF_TRUE(online_cpus[0]==-1);
+
+        int IA32_FIXED_CTR_CTL = 909;	//38D
+        int IA32_FIXED_CTR_CTL_Value;
+        IA32_FIXED_CTR_CTL_Value = get_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 63, 0, &error_indx);
+        SET_IF_TRUE(error_indx,online_cpus[0],-1);
+        RETURN_IF_TRUE(online_cpus[0]==-1);
+
+
+        IA32_MPERF = get_msr_value (CPU_NUM, 231, 7, 0, &error_indx);
+        SET_IF_TRUE(error_indx,online_cpus[0],-1);
+        RETURN_IF_TRUE(online_cpus[0]==-1);
+
+        IA32_APERF = get_msr_value (CPU_NUM, 232, 7, 0, &error_indx);
+        SET_IF_TRUE(error_indx,online_cpus[0],-1);
+        RETURN_IF_TRUE(online_cpus[0]==-1);
+
+        CPU_CLK_UNHALTED_CORE = get_msr_value (CPU_NUM, 778, 63, 0, &error_indx);
+        SET_IF_TRUE(error_indx,online_cpus[0],-1);
+        RETURN_IF_TRUE(online_cpus[0]==-1);
+
+        CPU_CLK_UNHALTED_REF = get_msr_value (CPU_NUM, 779, 63, 0, &error_indx);
+        SET_IF_TRUE(error_indx,online_cpus[0],-1);
+        RETURN_IF_TRUE(online_cpus[0]==-1);
+
+        //SLEEP FOR 1 SECOND (500ms is also alright)
+        nanosleep (&one_second_sleep, NULL);
+        IA32_MPERF = get_msr_value (CPU_NUM, 231, 7, 0, &error_indx) - IA32_MPERF;
+        SET_IF_TRUE(error_indx,online_cpus[0],-1);
+        RETURN_IF_TRUE(online_cpus[0]==-1);
+
+        IA32_APERF = get_msr_value (CPU_NUM, 232, 7, 0, &error_indx) - IA32_APERF;
+        SET_IF_TRUE(error_indx,online_cpus[0],-1);
+        RETURN_IF_TRUE(online_cpus[0]==-1);
+
+        mvprintw (4 + printw_offset, 0,"  CPU Multiplier %dx || Bus clock frequency (BCLK) %0.2f MHz \n",	CPU_Multiplier, BLCK);
+
+        if (numCPUs <= 0) {
+            sprintf (string_ptr1, "  Max TURBO Multiplier (if Enabled) with 0 cores is");
+            sprintf (string_ptr2, " %dx/%dx ", MAX_TURBO_1C, MAX_TURBO_2C);
+        }
+        if (numCPUs >= 1 && numCPUs < 4) {
+            sprintf (string_ptr1, "  Max TURBO Multiplier (if Enabled) with 1/2 Cores is");
+            sprintf (string_ptr2, "  ");
+        }
+        if (numCPUs >= 2 && numCPUs < 6) {
+            sprintf (string_ptr1, "  Max TURBO Multiplier (if Enabled) with 1/2/3/4 Cores is");
+            sprintf (string_ptr2, " %dx/%dx/%dx/%dx ", MAX_TURBO_1C, MAX_TURBO_2C, MAX_TURBO_3C, MAX_TURBO_4C);
+        }
+        if (numCPUs >= 2 && numCPUs >= 6) {	// Gulftown 6-cores, Nehalem-EX
+            sprintf (string_ptr1, "  Max TURBO Multiplier (if Enabled) with 1/2/3/4/5/6 Cores is");
+            sprintf (string_ptr2, " %dx/%dx/%dx/%dx/%dx/%dx ", MAX_TURBO_1C, MAX_TURBO_2C, MAX_TURBO_3C, MAX_TURBO_4C,
+                     MAX_TURBO_5C, MAX_TURBO_6C);
+        }
+
+        numCPUs = core_list_size_phy;
+        numPhysicalCores = core_list_size_phy;
+        numLogicalCores = core_list_size_log;
+
+        //if (socket_0.socket_num == 0) {
+            mvprintw (19, 0, "C0 = Processor running without halting");
+            mvprintw (20, 0, "C1 = Processor running with halts (States >C0 are power saver)");
+            mvprintw (21, 0, "C3 = Cores running with PLL turned off and core cache turned off");
+            mvprintw (22, 0, "C6 = Everything in C3 + core state saved to last level cache");
+            mvprintw (23, 0, "  Above values in table are in percentage over the last 1 sec");
+//            mvprintw (24, 0, "Total Logical Cores: [%d], Total Physical Cores: [%d] \n",	numLogicalCores, numPhysicalCores);
+            mvprintw (24, 0, "[core-id] refers to core-id number in /proc/cpuinfo");
+            mvprintw (25, 0, "'Garbage Values' message printed when garbage values are read");
+            mvprintw (26, 0, "  Ctrl+C to exit");
+        //}
+
+        mvprintw (6 + printw_offset, 0, "Socket [%d] - [physical cores=%d, logical cores=%d, max online cores ever=%d] \n", socket_0.socket_num, numPhysicalCores, numLogicalCores,*max_observed_cpu);
+
+        mvprintw (9 + printw_offset, 0, "%s %s\n", string_ptr1, string_ptr2);
+
+        if (TURBO_MODE == 1) {
+            mvprintw (7 + printw_offset, 0, "  TURBO ENABLED on %d Cores, %s\n", numPhysicalCores, HT_ON_str);
+            TRUE_CPU_FREQ = BLCK * ((double) CPU_Multiplier + 1);
+            mvprintw (8 + printw_offset, 0, "  Max Frequency without considering Turbo %0.2f MHz (%0.2f x [%d]) \n", TRUE_CPU_FREQ, BLCK, CPU_Multiplier + 1);
+        } else {
+            mvprintw (7 + printw_offset, 0, "  TURBO DISABLED on %d Cores, %s\n", numPhysicalCores, HT_ON_str);
+            TRUE_CPU_FREQ = BLCK * ((double) CPU_Multiplier);
+            mvprintw (8 + printw_offset, 0,"  Max Frequency without considering Turbo %0.2f MHz (%0.2f x [%d]) \n", TRUE_CPU_FREQ, BLCK, CPU_Multiplier);
+        }
+
+        //Primarily for 32-bit users, found that after sometimes the counters loopback, so inorder
+        //to prevent loopback, reset the counters back to 0 after 10 iterations roughly 10 secs
+        if (*kk_1 > 10) {
+            *kk_1 = 0;
+            for (i = 0; i <  numCPUs; i++) {
+                //Set up the performance counters and then start reading from them
+                assert(i < MAX_SK_PROCESSORS);
+                CPU_NUM = core_list[i];
+                ii = core_list[i];
+                assert(i < MAX_PROCESSORS); //online_cpus[i]
+                assert(ii < numCPUs_max);
+
+                IA32_PERF_GLOBAL_CTRL_Value =	get_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 63, 0, &error_indx);
+                SET_IF_TRUE(error_indx,online_cpus[i],-1);
+                CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+                set_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 0x700000003LLU);
+
+                IA32_FIXED_CTR_CTL_Value = get_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 63, 0, &error_indx);
+                SET_IF_TRUE(error_indx,online_cpus[i],-1);
+                CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+                set_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 819);
+
+                IA32_PERF_GLOBAL_CTRL_Value =	get_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 63, 0, &error_indx);
+                SET_IF_TRUE(error_indx,online_cpus[i],-1);
+                CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+                IA32_FIXED_CTR_CTL_Value = get_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 63, 0, &error_indx);
+                SET_IF_TRUE(error_indx,online_cpus[i],-1);
+                CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+                old_val_CORE[ii] = get_msr_value (CPU_NUM, 778, 63, 0, &error_indx);
+                SET_IF_TRUE(error_indx,online_cpus[i],-1);
+                CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+                old_val_REF[ii] = get_msr_value (CPU_NUM, 779, 63, 0, &error_indx);
+                SET_IF_TRUE(error_indx,online_cpus[i],-1);
+                CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+                old_val_C3[ii] = get_msr_value (CPU_NUM, 1020, 63, 0, &error_indx);
+                SET_IF_TRUE(error_indx,online_cpus[i],-1);
+                CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+                old_val_C6[ii] = get_msr_value (CPU_NUM, 1021, 63, 0, &error_indx);
+                SET_IF_TRUE(error_indx,online_cpus[i],-1);
+                CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+		if(prog_options.i7_version.sandy_bridge){
+			//table b-20 in 325384 and only for sandy bridge
+		        old_val_C7[ii] = get_msr_value (CPU_NUM, 1022, 63, 0, &error_indx);
+		        SET_IF_TRUE(error_indx,online_cpus[i],-1);
+		        CONTINUE_IF_TRUE(online_cpus[i]==-1);
+		}
+
+                old_TSC[ii] = rdtsc ();
+            }
+        }
+        (*kk_1)++;
+        nanosleep (&one_second_sleep, NULL);
+	if(prog_options.i7_version.sandy_bridge){
+            mvprintw (11 + printw_offset, 0, "\tCore [core-id]  :Actual Freq (Mult.)\t  C0%%   Halt(C1)%%  C3 %%   C6 %%   C7 %%  Temp\n");
+	}else{
+            mvprintw (11 + printw_offset, 0, "\tCore [core-id]  :Actual Freq (Mult.)\t  C0%%   Halt(C1)%%  C3 %%   C6 %%  Temp\n");
+	}
+        //estimate the CPU speed
+        estimated_mhz = estimate_MHz ();
+
+        for (i = 0; i <  numCPUs; i++) {
+            //read from the performance counters
+            //things like halted unhalted core cycles
+
+            assert(i < MAX_SK_PROCESSORS);
+            CPU_NUM = core_list[i];
+            ii = core_list[i];
+            assert(i < MAX_PROCESSORS); //online_cpus[i]
+            assert(ii < numCPUs_max);
+
+            new_val_CORE[ii] = get_msr_value (CPU_NUM, 778, 63, 0, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[i],-1);
+            CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+            new_val_REF[ii] = get_msr_value (CPU_NUM, 779, 63, 0, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[i],-1);
+            CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+            new_val_C3[ii] = get_msr_value (CPU_NUM, 1020, 63, 0, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[i],-1);
+            CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+            new_val_C6[ii] = get_msr_value (CPU_NUM, 1021, 63, 0, &error_indx);
+            SET_IF_TRUE(error_indx,online_cpus[i],-1);
+            CONTINUE_IF_TRUE(online_cpus[i]==-1);
+		
+	    if(prog_options.i7_version.sandy_bridge){
+		new_val_C7[ii] = get_msr_value (CPU_NUM, 1022, 63, 0, &error_indx);
+		SET_IF_TRUE(error_indx,online_cpus[i],-1);
+	        CONTINUE_IF_TRUE(online_cpus[i]==-1);		
+	    }
+
+            new_TSC[ii] = rdtsc ();
+
+            if (old_val_CORE[ii] > new_val_CORE[ii]) {			//handle overflow
+                CPU_CLK_UNHALTED_CORE = (UINT64_MAX - old_val_CORE[ii]) + new_val_CORE[ii];
+            } else {
+                CPU_CLK_UNHALTED_CORE = new_val_CORE[ii] - old_val_CORE[ii];
+            }
+
+            //number of TSC cycles while its in halted state
+            if ((new_TSC[ii] - old_TSC[ii]) < CPU_CLK_UNHALTED_CORE) {
+                CPU_CLK_C1 = 0;
+            } else {
+                CPU_CLK_C1 = ((new_TSC[ii] - old_TSC[ii]) - CPU_CLK_UNHALTED_CORE);
+            }
+
+            if (old_val_REF[ii] > new_val_REF[ii]) {			//handle overflow
+                CPU_CLK_UNHALTED_REF = (UINT64_MAX - old_val_REF[ii]) + new_val_REF[ii];	//3.40282366921e38
+            } else {
+                CPU_CLK_UNHALTED_REF = new_val_REF[ii] - old_val_REF[ii];
+            }
+
+            if (old_val_C3[ii] > new_val_C3[ii]) {			//handle overflow
+                CPU_CLK_C3 = (UINT64_MAX - old_val_C3[ii]) + new_val_C3[ii];
+            } else {
+                CPU_CLK_C3 = new_val_C3[ii] - old_val_C3[ii];
+            }
+
+            if (old_val_C6[ii] > new_val_C6[ii]) {			//handle overflow
+                CPU_CLK_C6 = (UINT64_MAX - old_val_C6[ii]) + new_val_C6[ii];
+            } else {
+                CPU_CLK_C6 = new_val_C6[ii] - old_val_C6[ii];
+            }
+
+	    if(prog_options.i7_version.sandy_bridge){
+	        if (old_val_C7[ii] > new_val_C7[ii]) {			//handle overflow
+                    CPU_CLK_C7 = (UINT64_MAX - old_val_C7[ii]) + new_val_C7[ii];
+                } else {
+                    CPU_CLK_C7 = new_val_C7[ii] - old_val_C7[ii];
+                }
+	    }
+
+            _FREQ[ii] =
+                THRESHOLD_BETWEEN_0_6000(estimated_mhz * ((long double) CPU_CLK_UNHALTED_CORE /
+                                         (long double) CPU_CLK_UNHALTED_REF));
+            _MULT[ii] = _FREQ[ii] / BLCK;
+
+            C0_time[ii] = ((long double) CPU_CLK_UNHALTED_REF /
+                           (long double) (new_TSC[ii] - old_TSC[ii]));
+            C1_time[ii] = ((long double) CPU_CLK_C1 /
+                           (long double) (new_TSC[ii] - old_TSC[ii]));
+            C3_time[ii] = ((long double) CPU_CLK_C3 /
+                           (long double) (new_TSC[ii] - old_TSC[ii]));
+            C6_time[ii] = ((long double) CPU_CLK_C6 /
+                           (long double) (new_TSC[ii] - old_TSC[ii]));
+
+	    if(prog_options.i7_version.sandy_bridge){
+	        C7_time[ii] = ((long double) CPU_CLK_C7 /
+                               (long double) (new_TSC[ii] - old_TSC[ii]));
+	    }
+
+            if (C0_time[ii] < 1e-2) {
+                if (C0_time[ii] > 1e-4) {
+                    C0_time[ii] = 0.01;
+                } else {
+                    C0_time[ii] = 0;
+                }
+            }
+            if (C1_time[ii] < 1e-2) {
+                if (C1_time[ii] > 1e-4) {
+                    C1_time[ii] = 0.01;
+                } else {
+                    C1_time[ii] = 0;
+                }
+            }
+            if (C3_time[ii] < 1e-2) {
+                if (C3_time[ii] > 1e-4) {
+                    C3_time[ii] = 0.01;
+                } else {
+                    C3_time[ii] = 0;
+                }
+            }
+            if (C6_time[ii] < 1e-2) {
+                if (C6_time[ii] > 1e-4) {
+                    C6_time[ii] = 0.01;
+                } else {
+                    C6_time[ii] = 0;
+                }
+            }
+	    if(prog_options.i7_version.sandy_bridge){
+	        if (C7_time[ii] < 1e-2) {
+                   if (C7_time[ii] > 1e-4) {
+                       C7_time[ii] = 0.01;
+                   } else {
+                       C7_time[ii] = 0;
+                   }
+                }
+	    }
+	}
+        //CHECK IF ALL COUNTERS ARE CORRECT AND NO GARBAGE VALUES ARE PRESENT
+        //If there is any garbage values set print_core[i] to 0
+        for (ii = 0; ii <  numCPUs; ii++) {
+            assert(ii < MAX_SK_PROCESSORS);
+            i = core_list[ii];
+	    if(prog_options.i7_version.sandy_bridge){
+	      if ( !IS_THIS_BETWEEN_0_100(C0_time[i] * 100) ||
+                    !IS_THIS_BETWEEN_0_100(C1_time[i] * 100 - (C3_time[i] + C6_time[i]) * 100) ||
+                    !IS_THIS_BETWEEN_0_100(C3_time[i] * 100) ||
+                    !IS_THIS_BETWEEN_0_100(C6_time[i] * 100) ||
+                    !IS_THIS_BETWEEN_0_100(C7_time[i] * 100) ||
+                    isinf(_FREQ[i]) )
+                  print_core[ii]=0;
+              else
+                  print_core[ii]=1;
+	    }else{
+	      if ( !IS_THIS_BETWEEN_0_100(C0_time[i] * 100) ||
+                    !IS_THIS_BETWEEN_0_100(C1_time[i] * 100 - (C3_time[i] + C6_time[i]) * 100) ||
+                    !IS_THIS_BETWEEN_0_100(C3_time[i] * 100) ||
+                    !IS_THIS_BETWEEN_0_100(C6_time[i] * 100) ||
+                    isinf(_FREQ[i]) )
+                  print_core[ii]=0;
+              else
+                  print_core[ii]=1;
+	    }
+        }
+
+        //Now print the information about the cores. Print garbage values message if there is garbage
+        for (ii = 0; ii <  numCPUs; ii++) {
+            assert(ii < MAX_SK_PROCESSORS);
+            i = core_list[ii];
+
+	    if(prog_options.i7_version.sandy_bridge){
+	        //there is a bit of leeway to be had as the total counts might deviate
+	        //if this happens c1_time might be negative so just adjust so that it is thresholded to 0
+	        c1_time = C1_time[i] * 100 - (C3_time[i] + C6_time[i] + C7_time[i]) * 100;
+	        if (!isnan(c1_time) && !isinf(c1_time)) {
+                    if (c1_time <= 0) {
+		    c1_time=0;
+                    }
+	        }
+	        if (print_core[ii])
+                    mvprintw (12 + ii + printw_offset, 0, "\tCore %d [%d]:\t  %0.2f (%.2fx)\t%4.3Lg\t%4.3Lg\t%4.3Lg\t%4.3Lg\t%4.3Lg\t%d\n",
+                          ii + 1, core_list[ii], _FREQ[i], _MULT[i], THRESHOLD_BETWEEN_0_100(C0_time[i] * 100),
+                          THRESHOLD_BETWEEN_0_100(c1_time), THRESHOLD_BETWEEN_0_100(C3_time[i] * 100), THRESHOLD_BETWEEN_0_100(C6_time[i] * 100),THRESHOLD_BETWEEN_0_100(C7_time[i] * 100),
+			  Read_Thermal_Status_CPU(core_list[ii]));	//C0_time[i]*100+C1_time[i]*100 around 100
+	        else
+                    mvprintw (12 + ii + printw_offset, 0, "\tCore %d [%d]:\t  Garbage Values\n", ii + 1, core_list[ii]);
+	    }else{
+	        //there is a bit of leeway to be had as the total counts might deviate
+	        //if this happens c1_time might be negative so just adjust so that it is thresholded to 0
+	        c1_time = C1_time[i] * 100 - (C3_time[i] + C6_time[i]) * 100;
+	        if (!isnan(c1_time) && !isinf(c1_time)) {
+                    if (c1_time <= 0) {
+		    c1_time=0;
+                    }
+	        }
+	        if (print_core[ii])
+                    mvprintw (12 + ii + printw_offset, 0, "\tCore %d [%d]:\t  %0.2f (%.2fx)\t%4.3Lg\t%4.3Lg\t%4.3Lg\t%4.3Lg\t%d\n",
+                          ii + 1, core_list[ii], _FREQ[i], _MULT[i], THRESHOLD_BETWEEN_0_100(C0_time[i] * 100),
+                          THRESHOLD_BETWEEN_0_100(c1_time), THRESHOLD_BETWEEN_0_100(C3_time[i] * 100), THRESHOLD_BETWEEN_0_100(C6_time[i] * 100),Read_Thermal_Status_CPU(core_list[ii]));	//C0_time[i]*100+C1_time[i]*100 around 100
+	        else
+                    mvprintw (12 + ii + printw_offset, 0, "\tCore %d [%d]:\t  Garbage Values\n", ii + 1, core_list[ii]);
+	    }
+        }
+
+        /*k=0;
+        for (ii = 00; ii < *max_observed_cpu; ii++)
+        {
+              	if (in_core_list(ii,core_list)){
+              		continue;
+              	}else{
+              		mvprintw (12 + k + numCPUs + printw_offset, 0, "\tProcessor %d [%d]:  OFFLINE\n", k + numCPUs + 1, ii);
+              	}
+              	k++;
+        }*/
+
+        //FOR THE REST OF THE CORES (i.e. the offline cores+non-present cores=6 )
+        //I have space allocated for 6 cores to be printed per socket so from all the present cores
+        //till 6 print a blank line
+
+        //for(ii=*max_observed_cpu; ii<6; ii++)
+        for (ii = numCPUs; ii<6; ii++)
+            mvprintw (12 + ii + printw_offset, 0, "\n");
+
+        TRUE_CPU_FREQ = 0;
+        
+        logOpenFile_single();
+        
+        //time_t time_to_save;
+        //logCpuFreq_single_d(time(&time_to_save));
+        clock_gettime(CLOCK_REALTIME, &global_ts);
+        logCpuFreq_single_ts( &global_ts);
+         
+        logCpuCstates_single_ts( &global_ts);
+        
+        for (ii = 0; ii < numCPUs; ii++) {
+            assert(ii < MAX_SK_PROCESSORS);
+            i = core_list[ii];
+            if ( (_FREQ[i] > TRUE_CPU_FREQ) && (print_core[ii]) && !isinf(_FREQ[i]) ) {
+                TRUE_CPU_FREQ = _FREQ[i];
+            }
+            if ( (print_core[ii]) && !isinf(_FREQ[i]) ) {
+                logCpuFreq_single(_FREQ[i]);
+            }
+            logCpuCstates_single_c(" [");
+            logCpuCstates_single((float)THRESHOLD_BETWEEN_0_100(C0_time[i] * 100));  logCpuCstates_single_c(",");
+            c1_time = C1_time[i] * 100 - (C3_time[i] + C6_time[i] + C7_time[i]) * 100;
+            logCpuCstates_single((float)THRESHOLD_BETWEEN_0_100(c1_time));           logCpuCstates_single_c(",");
+            logCpuCstates_single((float)THRESHOLD_BETWEEN_0_100(C3_time[i] * 100));  logCpuCstates_single_c(",");
+            logCpuCstates_single((float)THRESHOLD_BETWEEN_0_100(C6_time[i] * 100)); 
+            if(prog_options.i7_version.sandy_bridge){
+                logCpuCstates_single_c(",");
+                logCpuCstates_single((float)THRESHOLD_BETWEEN_0_100(C7_time[i] * 100));
+            } 
+            logCpuCstates_single_c("]\t");
+        }
+		//        logCpuCstates_single_c("\n");
+        logCloseFile_single();
+        
+        mvprintw (10 + printw_offset, 0,
+                  "  Real Current Frequency %0.2f MHz [%0.2f x %0.2f] (Max of below)\n", TRUE_CPU_FREQ, BLCK, TRUE_CPU_FREQ/BLCK);
+
+        refresh ();
+
+        //shift the new values to the old counter values
+        //so that the next time we use those to find the difference
+        memcpy (old_val_CORE, new_val_CORE,
+                sizeof (*old_val_CORE) * numCPUs);
+        memcpy (old_val_REF, new_val_REF, sizeof (*old_val_REF) * numCPUs);
+        memcpy (old_val_C3, new_val_C3, sizeof (*old_val_C3) * numCPUs);
+        memcpy (old_val_C6, new_val_C6, sizeof (*old_val_C6) * numCPUs);
+
+	if(prog_options.i7_version.sandy_bridge){
+	    memcpy (old_val_C7, new_val_C7, sizeof (*old_val_C7) * numCPUs);
+	}
+
+        memcpy (tvstart, tvstop, sizeof (*tvstart) * numCPUs);
+        memcpy (old_TSC, new_TSC, sizeof (*old_TSC) * numCPUs);
+    } else {
+        // If all the cores in the socket go offline, just erase the whole screen
+        //WELL for single socket machine this code will never be executed. lol
+        //atleast 1 core will be online so ...
+        //for (ii = 0 ; ii<14; ii++)
+        //    mvprintw (3 + ii + printw_offset, 0, "Ending up here\n");
+        //print_socket_information(&socket_0);
+    }
+
+}
+
+void print_i7z_single ()
+{
+    struct cpu_heirarchy_info chi;
+    struct cpu_socket_info socket_0={.max_cpu=0, .socket_num=0, .processor_num={-1,-1,-1,-1,-1,-1,-1,-1}};
+    struct cpu_socket_info socket_1={.max_cpu=0, .socket_num=1, .processor_num={-1,-1,-1,-1,-1,-1,-1,-1}};
+
+    construct_CPU_Heirarchy_info(&chi);
+    construct_sibling_list(&chi);
+//      print_CPU_Heirarchy(chi);
+    construct_socket_information(&chi, &socket_0, &socket_1, socket_0_num, socket_1_num);
+//	  print_socket_information(&socket_0);
+//	  print_socket_information(&socket_1);
+
+    int printw_offset = (0) * 14;
+
+    //Make an array size max 8 (to accomdate Nehalem-EXEX -lol) to store the core-num that are candidates for a given socket
+    //removing it from here as it is already allocated in the function
+    //int *core_list, core_list_size_phy, core_list_size_log;
+
+    //iterator
+    int i;
+
+    //turbo_mode enabled/disabled flag
+    char TURBO_MODE;
+
+    double cpu_freq_cpuinfo;
+
+    cpu_freq_cpuinfo = cpufreq_info ();
+    //estimate the freq using the estimate_MHz() code that is almost mhz accurate
+    cpu_freq_cpuinfo = estimate_MHz ();
+
+    //Print a slew of information on the ncurses window
+    //I already print that in the loop so..
+    mvprintw (0, 0, "WAIT .... ");
+
+
+    //estimate the freq using the estimate_MHz() code that is almost mhz accurate
+    cpu_freq_cpuinfo = estimate_MHz ();
+    mvprintw (3, 0, "True Frequency (without accounting Turbo) %0.0f MHz\n",
+              cpu_freq_cpuinfo);
+
+
+    //MSR number and hi:low bit of that MSR
+    //This msr contains a lot of stuff, per socket wise
+    //one can pass any core number and then get in multiplier etc
+    int PLATFORM_INFO_MSR = 206;	//CE 15:8
+    int PLATFORM_INFO_MSR_low = 8;
+    int PLATFORM_INFO_MSR_high = 15;
+
+    unsigned long long int old_val_CORE[2][numCPUs_max], new_val_CORE[2][numCPUs_max];
+    unsigned long long int old_val_REF[2][numCPUs_max], new_val_REF[2][numCPUs_max];
+    unsigned long long int old_val_C3[2][numCPUs_max], new_val_C3[2][numCPUs_max];
+    unsigned long long int old_val_C6[2][numCPUs_max], new_val_C6[2][numCPUs_max];
+    unsigned long long int old_val_C7[2][numCPUs_max], new_val_C7[2][numCPUs_max];
+
+    unsigned long long int old_TSC[2][numCPUs_max], new_TSC[2][numCPUs_max];
+    long double C0_time[2][numCPUs_max], C1_time[2][numCPUs_max],
+    C3_time[2][numCPUs_max], C6_time[2][numCPUs_max], C7_time[2][numCPUs_max];
+    double _FREQ[2][numCPUs_max], _MULT[2][numCPUs_max];
+    struct timeval tvstart[2][numCPUs_max], tvstop[2][numCPUs_max];
+
+    struct timespec one_second_sleep;
+    one_second_sleep.tv_sec = 0;
+    one_second_sleep.tv_nsec = 499999999;	// 500msec
+
+
+
+    //Get turbo mode status by reading msr within turbo_status
+    TURBO_MODE = turbo_status ();
+
+    //Flags and other things about HT.
+    int HT_ON;
+    char HT_ON_str[30];
+
+    int kk_1 = 11;
+
+    //below variables is used to monitor if any cores went offline etc.
+    int online_cpus[MAX_PROCESSORS]; //Max 2 x Nehalem-EX with total 32 threads
+
+    double estimated_mhz=0;
+    int socket_num;
+
+    //below variables stores how many cpus were observed till date for the socket
+    int max_cpus_observed=0;
+
+    for (;;) {
+        construct_CPU_Heirarchy_info(&chi);
+        construct_sibling_list(&chi);
+        construct_socket_information(&chi, &socket_0, &socket_1, socket_0_num, socket_1_num);
+        
+
+        //HT enabled if num logical > num physical cores
+        if (chi.HT==1) {
+            strncpy (HT_ON_str, "Hyper Threading ON\0", 30);
+            HT_ON = 1;
+        } else {
+            strncpy (HT_ON_str, "Hyper Threading OFF\0", 30);
+            HT_ON = 0;
+        }
+
+        refresh ();
+
+        SET_ONLINE_ARRAY_PLUS1(online_cpus)
+
+        //In the function calls below socket_num is set to the socket to print for
+        //printw_offset is the offset gap between the printing of the two sockets
+        //kk_1 and kk_2 are the variables that have to be set, i have to use them internally
+        //so in future if there are more sockets to be printed, add more kk_*
+        socket_num=0;
+        printw_offset=0;
+        
+        //printf("socket0 max cpu %d\n",socket_0.max_cpu);
+        //printf("socket1 max cpu %d\n",socket_0.max_cpu);
+        
+        
+        //below code in (else case) is to handle when for 2 sockets system, cpu1 is populated and cpu0 is empty.
+        //single socket code but in an intelligent manner and not assuming that cpu0 is always populated before cpu1
+        if(socket_0.max_cpu>1){
+            socket_num=0;
+            print_i7z_socket_single(socket_0, printw_offset, PLATFORM_INFO_MSR,  PLATFORM_INFO_MSR_high, PLATFORM_INFO_MSR_low,
+                                online_cpus, cpu_freq_cpuinfo, one_second_sleep, TURBO_MODE, HT_ON_str, &kk_1, old_val_CORE[socket_num],
+                                old_val_REF[socket_num], old_val_C3[socket_num], old_val_C6[socket_num],old_val_C7[socket_num],
+                                old_TSC[socket_num], estimated_mhz, new_val_CORE[socket_num], new_val_REF[socket_num], new_val_C3[socket_num],
+                                new_val_C6[socket_num],new_val_C7[socket_num], new_TSC[socket_num], _FREQ[socket_num], _MULT[socket_num], C0_time[socket_num], C1_time[socket_num],
+                                C3_time[socket_num], C6_time[socket_num],C7_time[socket_num], tvstart[socket_num], tvstop[socket_num], &max_cpus_observed);
+	}else{
+	    socket_num=1;
+	    print_i7z_socket_single(socket_1, printw_offset, PLATFORM_INFO_MSR,  PLATFORM_INFO_MSR_high, PLATFORM_INFO_MSR_low,
+		                online_cpus, cpu_freq_cpuinfo, one_second_sleep, TURBO_MODE, HT_ON_str, &kk_1, old_val_CORE[socket_num],
+                                old_val_REF[socket_num], old_val_C3[socket_num], old_val_C6[socket_num],old_val_C7[socket_num],
+                                old_TSC[socket_num], estimated_mhz, new_val_CORE[socket_num], new_val_REF[socket_num], new_val_C3[socket_num],
+                                new_val_C6[socket_num],new_val_C7[socket_num], new_TSC[socket_num], _FREQ[socket_num], _MULT[socket_num], C0_time[socket_num], C1_time[socket_num],
+                                C3_time[socket_num], C6_time[socket_num],C7_time[socket_num], tvstart[socket_num], tvstop[socket_num], &max_cpus_observed);
+	}
+    }
+
+}
+
+
+/*int Single_Socket(){
+	  int row, col;	// to store the number of rows and    //
+					// the number of colums of the screen //
+					// for NCURSES                        //
+
+  	  printf ("i7z DEBUG: In i7z Single_Socket()\n");
+
+	  sleep (3);
+
+	  //iterator
+	  int i;
+
+	  int error_indx;
+	  //cpu multiplier
+	  int CPU_Multiplier;
+	  //current blck value
+	  float BLCK;
+	  //turbo_mode enabled/disabled flag
+	  char TURBO_MODE;
+
+      int online_cpus[8];
+      SET_ONLINE_ARRAY_PLUS1(online_cpus)
+
+	  //Use Core-1 as the one to check for the turbo limit
+	  //Core number shouldnt matter
+	  int CPU_NUM = 0;
+	  //bits from 0-63 in this store the various maximum turbo limits
+	  int MSR_TURBO_RATIO_LIMIT = 429;
+	  // 3B defines till Max 4 Core and the rest bit values from 32:63 were reserved.
+	  //Bits:0-7  - core1
+	  int MAX_TURBO_1C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 7, 0, &error_indx);
+	  //Bits:15-8 - core2
+	  int MAX_TURBO_2C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 15, 8, &error_indx);
+	  //Bits:23-16 - core3
+	  int MAX_TURBO_3C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 23, 16, &error_indx);
+	  //Bits:31-24 - core4
+	  int MAX_TURBO_4C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 31, 24, &error_indx);
+
+	  //gulftown/Hexacore support
+	  //technically these should be the bits to get for core 5,6
+	  //Bits:39-32 - core4
+	  int MAX_TURBO_5C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 39, 32, &error_indx);
+	  //Bits:47-40 - core4
+	  int MAX_TURBO_6C = get_msr_value (CPU_NUM, MSR_TURBO_RATIO_LIMIT, 47, 40, &error_indx);
+
+
+
+	  //CPUINFO is wrong for i7 but correct for the number of physical and logical cores present
+	  //If Hyperthreading is enabled then, multiple logical processors will share a common CORE ID
+	  //http://www.redhat.com/magazine/022aug06/departments/tips_tricks/
+	  system
+		("cat /proc/cpuinfo |grep MHz|sed 's/cpu\\sMHz\\s*:\\s//'|tail -n 1 > /tmp/cpufreq.txt");
+	  system
+		("grep \"core id\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numPhysical.txt");
+	  system
+		("grep \"processor\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numLogical.txt");
+	  //At this step, /tmp/numPhysical contains number of physical cores in machine and
+	  //                      /tmp/numPhysical contains number of logical cores in machine
+
+
+	  //Open the parsed cpufreq file and obtain the cpufreq from /proc/cpuinfo
+	  FILE *tmp_file;
+	  tmp_file = fopen ("/tmp/cpufreq.txt", "r");
+	  char tmp_str[30];
+	  fgets (tmp_str, 30, tmp_file);
+	  double cpu_freq_cpuinfo = atof (tmp_str);
+	  fclose (tmp_file);
+
+	  //Parse the numPhysical and numLogical file to obtain the number of physical and logical core
+	  tmp_file = fopen ("/tmp/numPhysical.txt", "r");
+	  fgets (tmp_str, 30, tmp_file);
+	  numPhysicalCores = atoi (tmp_str);
+	  fclose (tmp_file);
+
+	  tmp_file = fopen ("/tmp/numLogical.txt", "r");
+	  fgets (tmp_str, 30, tmp_file);
+	  numLogicalCores = atoi (tmp_str);
+	  fclose (tmp_file);
+	  //reading of the number of cores is done
+
+	  fflush (stdout);
+	  sleep (1);
+
+	  //Setup stuff for ncurses
+	  initscr ();			// start the curses mode
+	  start_color ();
+	  getmaxyx (stdscr, row, col);	// get the number of rows and columns
+	  refresh ();
+	  //Setup for ncurses completed
+
+	  //Print a slew of information on the ncurses window
+	  mvprintw (0, 0, "Cpu speed from cpuinfo %0.2fMhz\n", cpu_freq_cpuinfo);
+	  mvprintw (1, 0,
+			"cpuinfo might be wrong if cpufreq is enabled. To guess correctly try estimating via tsc\n");
+	  mvprintw (2, 0, "Linux's inbuilt cpu_khz code emulated now\n\n");
+
+
+	  //estimate the freq using the estimate_MHz() code that is almost mhz accurate
+	  cpu_freq_cpuinfo = estimate_MHz ();
+	  mvprintw (3, 0, "True Frequency (without accounting Turbo) %0.0f MHz\n",
+			cpu_freq_cpuinfo);
+
+
+	  //MSR number and hi:low bit of that MSR
+	  //This msr contains a lot of stuff, per socket wise
+	  //one can pass any core number and then get in multiplier etc
+	  int PLATFORM_INFO_MSR = 206;	//CE 15:8
+	  int PLATFORM_INFO_MSR_low = 8;
+	  int PLATFORM_INFO_MSR_high = 15;
+
+	  //We just need one CPU (we use Core-1) to figure out the multiplier and the bus clock freq.
+	  //multiplier doesnt automatically include turbo
+	  //note turbo is not guaranteed, only promised
+	  //So this msr will only reflect the actual multiplier, rest has to be figured out
+	  CPU_NUM = 0;
+	  CPU_Multiplier = get_msr_value (CPU_NUM, PLATFORM_INFO_MSR, PLATFORM_INFO_MSR_high, PLATFORM_INFO_MSR_low, &error_indx);
+	  SET_IF_TRUE(error_indx,online_cpus[0],-1);
+
+	  //Blck is basically the true speed divided by the multiplier
+	  BLCK = cpu_freq_cpuinfo / CPU_Multiplier;
+	  mvprintw (4, 0,
+			"CPU Multiplier %dx || Bus clock frequency (BCLK) %0.2f MHz \n",
+			CPU_Multiplier, BLCK);
+
+	  //Get turbo mode status by reading msr within turbo_status
+	  TURBO_MODE = turbo_status ();	//get_msr_value(CPU_NUM,IA32_MISC_ENABLE, TURBO_FLAG_high,TURBO_FLAG_low);
+
+	  //to find how many cpus are enabled, we could have used sysconf but that will just give the logical numbers
+	  //if HT is enabled then the threads of the same core have the same C-state residency number so...
+	  //Its imperative to figure out the number of physical and number of logical cores.
+	  //sysconf(_SC_NPROCESSORS_ONLN);
+
+	  //number of CPUs is as told via cpuinfo
+	  int numCPUs = numPhysicalCores;
+
+	  //Flags and other things about HT.
+	  int HT_ON;
+	  char HT_ON_str[30];
+
+	  //HT enabled if num logical > num physical cores
+	  if (numLogicalCores > numPhysicalCores)
+		{
+		  //printf("Multiplier %d \n", CPU_Multiplier);
+		  strncpy (HT_ON_str, "Hyper Threading ON\0", 30);
+		  HT_ON = 1;
+		  //printf("Multiplier %d \n", CPU_Multiplier);
+		}
+	  else
+		{
+		  //printf("Multiplier %d \n", CPU_Multiplier);
+		  strncpy (HT_ON_str, "Hyper Threading OFF\0", 30);
+		  HT_ON = 0;
+		  //printf("Multiplier %d \n", CPU_Multiplier);
+		}
+
+	  //printf("Multiplier %d \n", CPU_Multiplier);
+
+	  if (TURBO_MODE == 1)
+		{				// && (CPU_Multiplier+1)==MAX_TURBO_2C){
+		  mvprintw (5, 0, "TURBO ENABLED on %d Cores, %s\n", numPhysicalCores,
+			HT_ON_str);
+		  TRUE_CPU_FREQ = BLCK * ((double) CPU_Multiplier + 1);
+		  mvprintw (6, 0, "True Frequency %0.2f MHz (%0.2f x [%d]) \n",
+			TRUE_CPU_FREQ, BLCK, CPU_Multiplier + 1);
+		}
+	  else
+		{
+		  mvprintw (5, 0, "TURBO DISABLED on %d Cores, %s\n",
+			numPhysicalCores, HT_ON_str);
+		  TRUE_CPU_FREQ = BLCK * ((double) CPU_Multiplier);
+		  mvprintw (6, 0, "True Frequency %0.2f MHz (%0.2f x [%d]) \n",
+			TRUE_CPU_FREQ, BLCK, CPU_Multiplier);
+		}
+
+
+	  if (numCPUs >= 2)
+		 {mvprintw (7, 0,"  Max TURBO (if Enabled) with 1/2 Core  active %dx / %dx\n", MAX_TURBO_1C, MAX_TURBO_2C);}
+	  if (numCPUs >= 4)
+		 {mvprintw (8, 0,"  Max TURBO (if Enabled) with 3/4 Cores active %dx / %dx\n", MAX_TURBO_3C, MAX_TURBO_4C);}
+	  if (numCPUs >= 6)
+		 {mvprintw (9, 0,"  Max TURBO (if Enabled) with 5/6 Cores active %dx / %dx\n", MAX_TURBO_5C, MAX_TURBO_6C);}
+
+	  mvprintw (22, 0, "C0 = Processor running without halting");
+	  mvprintw (23, 0,
+			"C1 = Processor running with halts (States >C0 are power saver)");
+	  mvprintw (24, 0,
+			"C3 = Cores running with PLL turned off and core cache turned off");
+	  mvprintw (25, 0,
+			"C6 = Everything in C3 + core state saved to last level cache");
+	  mvprintw (26, 0,
+			"  Above values in table are in percentage over the last 1 sec");
+	  mvprintw (27, 0,
+			" Total Logical Cores: [%d], Total Physical Cores: [%d] \n",
+			numLogicalCores, numPhysicalCores);
+
+	  mvprintw (29, 0, "  Ctrl+C to exit");
+
+
+	  int IA32_PERF_GLOBAL_CTRL = 911;	//38F
+	  int IA32_PERF_GLOBAL_CTRL_Value =	get_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 63, 0, &error_indx);
+	  SET_IF_TRUE(error_indx,online_cpus[0],-1);
+	  int IA32_FIXED_CTR_CTL = 909;	//38D
+	  int IA32_FIXED_CTR_CTL_Value = get_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 63, 0, &error_indx);
+	  SET_IF_TRUE(error_indx,online_cpus[0],-1);
+
+	  //printf("IA32_PERF_GLOBAL_CTRL %d\n",IA32_PERF_GLOBAL_CTRL_Value);
+	  //printf("IA32_FIXED_CTR_CTL %d\n",IA32_FIXED_CTR_CTL_Value);
+
+	  unsigned long long int CPU_CLK_UNHALTED_CORE, CPU_CLK_UNHALTED_REF,
+		CPU_CLK_C3, CPU_CLK_C6, CPU_CLK_C1;
+
+	  CPU_CLK_UNHALTED_CORE = get_msr_value (CPU_NUM, 778, 63, 0, &error_indx);
+	  SET_IF_TRUE(error_indx,online_cpus[0],-1);
+	  CPU_CLK_UNHALTED_REF = get_msr_value (CPU_NUM, 779, 63, 0, &error_indx);
+	  SET_IF_TRUE(error_indx,online_cpus[0],-1);
+
+	  unsigned long long int old_val_CORE[numCPUs], new_val_CORE[numCPUs];
+	  unsigned long long int old_val_REF[numCPUs], new_val_REF[numCPUs];
+	  unsigned long long int old_val_C3[numCPUs], new_val_C3[numCPUs];
+	  unsigned long long int old_val_C6[numCPUs], new_val_C6[numCPUs];
+	//  unsigned long int old_val_C1[numCPUs], new_val_C1[numCPUs];
+
+	  unsigned long long int old_TSC[numCPUs], new_TSC[numCPUs];
+
+	  struct timeval tvstart[numCPUs], tvstop[numCPUs];
+
+	  struct timespec one_second_sleep;
+	  one_second_sleep.tv_sec = 0;
+	  one_second_sleep.tv_nsec = 999999999;	// 1000msec
+
+
+	  unsigned long int IA32_MPERF = get_msr_value (CPU_NUM, 231, 7, 0, &error_indx);
+	  SET_IF_TRUE(error_indx,online_cpus[0],-1);
+	  unsigned long int IA32_APERF = get_msr_value (CPU_NUM, 232, 7, 0, &error_indx);
+	  SET_IF_TRUE(error_indx,online_cpus[0],-1);
+	  mvprintw (11, 0, "Wait...\n");
+	  refresh ();
+	  nanosleep (&one_second_sleep, NULL);
+	  IA32_MPERF = get_msr_value (CPU_NUM, 231, 7, 0, &error_indx) - IA32_MPERF;
+	  SET_IF_TRUE(error_indx,online_cpus[0],-1);
+	  IA32_APERF = get_msr_value (CPU_NUM, 232, 7, 0, &error_indx) - IA32_APERF;
+	  SET_IF_TRUE(error_indx,online_cpus[0],-1);
+
+	  //printf("Diff. i n APERF = %u, MPERF = %d\n", IA32_MPERF, IA32_APERF);
+
+	  long double C0_time[numCPUs], C1_time[numCPUs], C3_time[numCPUs],
+		C6_time[numCPUs];
+	  double _FREQ[numCPUs], _MULT[numCPUs];
+	  refresh ();
+
+	  mvprintw (11, 0, "Current Freqs\n");
+
+	  int kk=11, ii;
+
+	  double estimated_mhz;
+	  for (;;)
+		{
+		      SET_ONLINE_ARRAY_PLUS1(online_cpus)
+			  if (kk > 10){
+				kk=0;
+				for (ii = 0; ii < numCPUs; ii++)
+				{
+				  //Set up the performance counters and then start reading from them
+				  CPU_NUM = ii;
+				  IA32_PERF_GLOBAL_CTRL_Value =	get_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 63, 0, &error_indx);
+				  SET_IF_TRUE(error_indx,online_cpus[ii],-1);
+				  CONTINUE_IF_TRUE(online_cpus[ii]==-1);
+
+				  set_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 0x700000003LLU);
+
+				  IA32_FIXED_CTR_CTL_Value = get_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 63, 0, &error_indx);
+				  SET_IF_TRUE(error_indx,online_cpus[ii],-1);
+				  CONTINUE_IF_TRUE(online_cpus[ii]==-1);
+
+				  set_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 819);
+
+				  IA32_PERF_GLOBAL_CTRL_Value =	get_msr_value (CPU_NUM, IA32_PERF_GLOBAL_CTRL, 63, 0, &error_indx);
+				  SET_IF_TRUE(error_indx,online_cpus[ii],-1);
+				  CONTINUE_IF_TRUE(online_cpus[ii]==-1);
+
+                  IA32_FIXED_CTR_CTL_Value = get_msr_value (CPU_NUM, IA32_FIXED_CTR_CTL, 63, 0, &error_indx);
+				  SET_IF_TRUE(error_indx,online_cpus[ii],-1);
+				  CONTINUE_IF_TRUE(online_cpus[ii]==-1);
+
+				  old_val_CORE[ii] = get_msr_value (CPU_NUM, 778, 63, 0, &error_indx);
+				  SET_IF_TRUE(error_indx,online_cpus[ii],-1);
+				  CONTINUE_IF_TRUE(online_cpus[ii]==-1);
+
+				  old_val_REF[ii] = get_msr_value (CPU_NUM, 779, 63, 0, &error_indx);
+				  SET_IF_TRUE(error_indx,online_cpus[ii],-1);
+				  CONTINUE_IF_TRUE(online_cpus[ii]==-1);
+
+				  old_val_C3[ii] = get_msr_value (CPU_NUM, 1020, 63, 0, &error_indx);
+				  SET_IF_TRUE(error_indx,online_cpus[ii],-1);
+				  CONTINUE_IF_TRUE(online_cpus[ii]==-1);
+
+				  old_val_C6[ii] = get_msr_value (CPU_NUM, 1021, 63, 0, &error_indx);
+				  SET_IF_TRUE(error_indx,online_cpus[ii],-1);
+				  CONTINUE_IF_TRUE(online_cpus[ii]==-1);
+
+				  old_TSC[ii] = rdtsc ();
+				}
+			  }
+			  kk++;
+		  nanosleep (&one_second_sleep, NULL);
+		  mvprintw (13, 0,
+			"\tProcessor  :Actual Freq (Mult.)  C0%%   Halt(C1)%%  C3 %%   C6 %%\n");
+
+		  estimated_mhz = estimate_MHz ();
+		  for (i = 0; i < numCPUs; i++)
+			{
+			  //read from the performance counters
+			  //things like halted unhalted core cycles
+
+			  CPU_NUM = i;
+			  new_val_CORE[i] = get_msr_value (CPU_NUM, 778, 63, 0, &error_indx);
+			  SET_IF_TRUE(error_indx,online_cpus[i],-1);
+			  CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+			  new_val_REF[i] = get_msr_value (CPU_NUM, 779, 63, 0, &error_indx);
+			  SET_IF_TRUE(error_indx,online_cpus[i],-1);
+			  CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+			  new_val_C3[i] = get_msr_value (CPU_NUM, 1020, 63, 0, &error_indx);
+			  SET_IF_TRUE(error_indx,online_cpus[i],-1);
+			  CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+			  new_val_C6[i] = get_msr_value (CPU_NUM, 1021, 63, 0, &error_indx);
+			  SET_IF_TRUE(error_indx,online_cpus[i],-1);
+			  CONTINUE_IF_TRUE(online_cpus[i]==-1);
+
+              new_TSC[i] = rdtsc ();
+
+			  if (old_val_CORE[i] > new_val_CORE[i])
+		  	  {	  //handle overflow
+				  CPU_CLK_UNHALTED_CORE = (UINT64_MAX - old_val_CORE[i]) + new_val_CORE[i];
+			  }else{
+				  CPU_CLK_UNHALTED_CORE = new_val_CORE[i] - old_val_CORE[i];
+			  }
+
+			  //number of TSC cycles while its in halted state
+			  if ((new_TSC[i] - old_TSC[i]) < CPU_CLK_UNHALTED_CORE)
+					{CPU_CLK_C1 = 0;}
+			  else
+					{CPU_CLK_C1 = ((new_TSC[i] - old_TSC[i]) - CPU_CLK_UNHALTED_CORE);}
+
+			  if (old_val_REF[i] > new_val_REF[i])
+			  {   //handle overflow
+				  CPU_CLK_UNHALTED_REF = (UINT64_MAX - old_val_REF[i]) + new_val_REF[i]; //3.40282366921e38
+			  }else{
+				  CPU_CLK_UNHALTED_REF = new_val_REF[i] - old_val_REF[i];
+			  }
+
+			  if (old_val_C3[i] > new_val_C3[i])
+			  {   //handle overflow
+				  CPU_CLK_C3 = (UINT64_MAX - old_val_C3[i]) + new_val_C3[i];
+			  }else{
+				  CPU_CLK_C3 = new_val_C3[i] - old_val_C3[i];
+			  }
+
+			  if (old_val_C6[i] > new_val_C6[i])
+			  {   //handle overflow
+				  CPU_CLK_C6 = (UINT64_MAX - old_val_C6[i]) + new_val_C6[i];
+			  }else{
+				  CPU_CLK_C6 = new_val_C6[i] - old_val_C6[i];
+			  }
+
+			  _FREQ[i] =
+				estimated_mhz * ((long double) CPU_CLK_UNHALTED_CORE /
+						   (long double) CPU_CLK_UNHALTED_REF);
+			  _MULT[i] = _FREQ[i] / BLCK;
+
+			  C0_time[i] = ((long double) CPU_CLK_UNHALTED_REF /
+						   (long double) (new_TSC[i] - old_TSC[i]));
+			  C1_time[i] = ((long double) CPU_CLK_C1 /
+						   (long double) (new_TSC[i] - old_TSC[i]));
+			  C3_time[i] = ((long double) CPU_CLK_C3 /
+						   (long double) (new_TSC[i] - old_TSC[i]));
+			  C6_time[i] = ((long double) CPU_CLK_C6 /
+					 	   (long double) (new_TSC[i] - old_TSC[i]));
+
+			  if (C0_time[i] < 1e-2)
+			  {
+				if (C0_time[i] > 1e-4)	{C0_time[i] = 0.01;}
+				else					{C0_time[i] = 0;}
+			  }
+			  if (C1_time[i] < 1e-2)
+			  {
+				if (C1_time[i] > 1e-4)	{C1_time[i] = 0.01;}
+				else					{C1_time[i] = 0;}
+			  }
+			  if (C3_time[i] < 1e-2)
+			  {
+				if (C3_time[i] > 1e-4)	{C3_time[i] = 0.01;}
+				else					{C3_time[i] = 0;}
+			  }
+			  if (C6_time[i] < 1e-2)
+			  {
+				if (C6_time[i] > 1e-4)	{C6_time[i] = 0.01;}
+				else					{C6_time[i] = 0;}
+			  }
+			  //printf("%lld  - %lld", CPU_CLK_C6, (new_TSC[i] - old_TSC[i]));
+		  }
+
+		  for (i = 0; i < numCPUs; i++){
+			if(online_cpus[i]==-1){
+				mvprintw (14 + i, 0, "\tProcessor %d:  OFFLINE\n",i + 1);
+			}else{
+				mvprintw (14 + i, 0, "\tProcessor %d:  %0.2f (%.2fx)\t%4.3Lg\t%4.3Lg\t%4.3Lg\t%4.3Lg\n", i + 1, _FREQ[i], _MULT[i],
+				      C0_time[i] * 100 , C1_time[i]* 100  - (C3_time[i] + C6_time[i] )* 100, C3_time[i]* 100 , C6_time[i]* 100);	//C0_time[i]*100+C1_time[i]*100 around 100
+			}
+		  }
+
+
+		  TRUE_CPU_FREQ = 0;
+		  for (i = 0; i < numCPUs; i++)
+		  {
+			  if (_FREQ[i] > TRUE_CPU_FREQ)
+			  {
+				  TRUE_CPU_FREQ = _FREQ[i];
+				  mvprintw (12, 0,
+					"True Frequency %0.2f MHz (Intel specifies largest of below to be running Freq)\n",
+					TRUE_CPU_FREQ);
+			  }
+		  }
+
+		  refresh ();
+
+		  //shift the new values to the old counter values
+		  //so that the next time we use those to find the difference
+		  memcpy (old_val_CORE, new_val_CORE,
+			  sizeof (unsigned long int) * numCPUs);
+		  memcpy (old_val_REF, new_val_REF, sizeof (unsigned long int) * numCPUs);
+		  memcpy (old_val_C3, new_val_C3, sizeof (unsigned long int) * numCPUs);
+		  memcpy (old_val_C6, new_val_C6, sizeof (unsigned long int) * numCPUs);
+		  memcpy (tvstart, tvstop, sizeof (struct timeval) * numCPUs);
+		  memcpy (old_TSC, new_TSC, sizeof (unsigned long long int) * numCPUs);
+	  }   //ENDOF INFINITE FOR LOOP
+	  exit (0);
+	  return (1);
+}*/

=== added directory '.pc/hyphen-used-as-minus-sign.patch'
=== added file '.pc/hyphen-used-as-minus-sign.patch/.timestamp'
=== added directory '.pc/hyphen-used-as-minus-sign.patch/doc'
=== added file '.pc/hyphen-used-as-minus-sign.patch/doc/i7z.man'
--- .pc/hyphen-used-as-minus-sign.patch/doc/i7z.man	1970-01-01 00:00:00 +0000
+++ .pc/hyphen-used-as-minus-sign.patch/doc/i7z.man	2013-08-15 05:58:18 +0000
@@ -0,0 +1,28 @@
+.TH i7z 1 "20 July 2012"
+.SH NAME
+i7z \- A better i7 (and now i3, i5) reporting tool for Linux.
+.SH SYNOPSIS
+\fBi7z [OPTION]\fP, [OPTION] is optional. i7z needs to be run in super user (root) mode.
+.SH DESCRIPTION
+i7z runs the i7z, ncurses based, program without any options. i7z will print out the C-states and temperature for i3, i5 and i7 based Core processors from Intel (including Nehalems, Sandy Bridge and Ivy Bridge). 
+.SH OPTIONS
+.TP
+\fB-h, --help \fPshow the list of options available with the i7z tool.
+.TP
+\fB-w  [a|l],  --write  [a,l] \fPLogging of the frequencies can be turned on with this options. Option "-w a" or "--write a" will append to the  log file. Option "-w l" or "--write l" will replace the log file.
+.TP
+\fB-l,  --logfile  [FILENAME] \fPChange  the  log file name to the specified FILENAME. Default logging file is cpu_freq_log.txt (single  socket) or cpu_freq_log_dual%d.txt (dual socket, %d is either 0, 1).
+.TP
+\fB--socket0  [SOCKETNUM], --socket1 [SOCKETNUM] \fPThe tool can print information for about 2 sockets at once at the most. The top view  will  be, by  default, of the first socket (controlled by --socket0) and the bottom view will be of the second socket (controlled by --socket1). Supply the appropriate value of 0 or 1 or more for SOCKETNUM (if there are more sockets on the machine) to show in the top and bottom view.
+.TP
+\fB--nogui \fPDisable the GUI. Useful when the only need is logging.
+.SH Example
+To print for two sockets and also change the log file (log to /tmp/logfilei7z)
+
+i7z \-\-socket0 0 \-\-socket1 1 \-logfile /tmp/logfilei7z \-w l
+
+.SH BUGS
+Do report bugs or feature enhancement as an issue at http://code.google.com/p/i7z.
+
+.SH AUTHORS
+Written in 2010, by Abhishek Jaiantilal (abhirana @ gmail.com). i7z  is licensed  under the terms of the GNU  General Public License (GPL) version 2.

=== removed directory '.pc/install-i7z_rw_registers'
=== added directory '.pc/install-i7z_rw_registers.patch'
=== added file '.pc/install-i7z_rw_registers.patch/.timestamp'
=== added file '.pc/install-i7z_rw_registers.patch/Makefile'
--- .pc/install-i7z_rw_registers.patch/Makefile	1970-01-01 00:00:00 +0000
+++ .pc/install-i7z_rw_registers.patch/Makefile	2013-08-15 05:58:18 +0000
@@ -0,0 +1,63 @@
+#
+# Makefile for i7z, GPL v2, License in COPYING
+#
+
+#makefile updated from patch by anestling
+
+#explicitly disable two scheduling flags as they cause segfaults, two more seem to crash the GUI version so putting them
+#here 
+CFLAGS_FOR_AVOIDING_SEG_FAULT = -fno-schedule-insns2  -fno-schedule-insns -fno-inline-small-functions -fno-caller-saves
+CFLAGS ?= -O3
+CFLAGS += $(CFLAGS_FOR_AVOIDING_SEG_FAULT) -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -DBUILD_MAIN -Wimplicit-function-declaration
+
+LBITS := $(shell getconf LONG_BIT)
+ifeq ($(LBITS),64)
+   CFLAGS += -Dx64_BIT
+else
+   CFLAGS += -Dx86
+endif
+
+CC       ?= gcc
+
+LIBS  += -lncurses -lpthread -lrt -lm
+INCLUDEFLAGS = 
+
+BIN	= i7z
+# PERFMON-BIN = perfmon-i7z #future version to include performance monitor, either standalone or integrated
+SRC	= i7z.c helper_functions.c i7z_Single_Socket.c i7z_Dual_Socket.c
+OBJ	= $(SRC:.c=.o)
+
+prefix ?= /usr
+sbindir = $(prefix)/sbin/
+docdir = $(prefix)/share/doc/$(BIN)/
+mandir ?= $(prefix)/share/man/
+
+all: clean test_exist
+
+message:
+	@echo "If the compilation complains about not finding ncurses.h, install ncurses (libncurses5-dev on ubuntu/debian)"
+
+bin: message $(OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $(BIN) $(OBJ) $(LIBS)
+
+#http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=644728 for -ltinfo on debian
+static-bin: message $(OBJ)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $(BIN) $(OBJ) -static-libgcc -DNCURSES_STATIC -static -lpthread -lncurses -lrt -lm -ltinfo
+
+# perfmon-bin: message $(OBJ)
+# 	$(CC) $(CFLAGS) $(LDFLAGS) -o $(PERFMON-BIN) perfmon-i7z.c helper_functions.c $(LIBS)
+
+test_exist: bin
+	@test -f i7z && echo 'Succeeded, now run sudo ./i7z' || echo 'Compilation failed'
+
+clean:
+	rm -f *.o $(BIN)
+
+distclean: clean
+	rm -f *~ \#*
+
+install:  $(BIN)
+	install -D -m 0644 doc/i7z.man $(DESTDIR)$(mandir)man1/i7z.1
+	install -D -m 755 $(BIN) $(DESTDIR)$(sbindir)$(BIN)
+	install -d $(DESTDIR)$(docdir)
+	install -m 0644 README.txt put_cores_offline.sh put_cores_online.sh MAKEDEV-cpuid-msr $(DESTDIR)$(docdir)

=== added file '.pc/install-i7z_rw_registers.patch/i7z_rw_registers.rb'
--- .pc/install-i7z_rw_registers.patch/i7z_rw_registers.rb	1970-01-01 00:00:00 +0000
+++ .pc/install-i7z_rw_registers.patch/i7z_rw_registers.rb	2013-08-15 05:58:18 +0000
@@ -0,0 +1,435 @@
+#* ----------------------------------------------------------------------- *
+# *
+# *   Under GPL v3
+# *   written by Abhishek Jaiantilal
+# *   much thanks to Antonio Meireles who suggested this idea & helped with testing 
+# *   run as      sudo ruby i7z_rw_registers.rb
+# *
+# * ----------------------------------------------------------------------- */
+
+#!/usr/bin/ruby
+
+def print_command_list()
+	print "Do you need help? \n"
+	print "Possible commands are \n" 
+	print "help : which will print this list again \n"
+	print "turbo : which examines the turbo status \n"
+	print "multiplier : examines the multipliers \n"
+	print "power : which prints current wattage of the system\n"
+	print "clock : allows for software clock modulation ( a form of throttling )\n"
+    print "system : allows to print some system info\n"
+	print "quit : which will quit the program or just do ctrl + c\n"
+end
+
+IA32_PERF_STATUS =  0x198  	#read only
+IA32_PERF_CTL = 0x199  		#read write
+IA32_MISC_ENABLE = 0x1a0
+
+def num_cores 
+    numcores = `cat /proc/cpuinfo | grep 'cpu cores' |head -n 1|sed 's/cpu cores\\s*:\\s//'`
+    return numcores.to_i
+end
+
+def nehalem_or_sandybridge
+    proc_type = `cat /proc/cpuinfo | grep flags |head -n 1| grep avx`
+    
+    if proc_type.chomp.length == 0
+        return 'Nehalem'
+    else 
+        return 'Sandy Bridge'
+    end
+end
+
+def turbo_command_list()
+	print "turbo : which examines the turbo status \n"
+	print "   probable commands are\n"
+	print	"	turbo status : get the current status of turbo\n"
+	print	"	turbo enable : enable turbo\n"
+	print	"	turbo disable : disable turbo\n"
+end
+
+def multiplier_command_list()
+	print "multiplier : which allows setting/examining multiplier \n"
+	print "   probable commands are\n"
+	print	"	multiplier set <number> : set the multiplier to given number and ONLY in decimals\n"
+	print	"	multiplier get : examine the current multiplier\n"
+end
+
+def power_command_list()
+	print "power : which allows setting/examining TDP / TDC\n"
+	print "   probable commands are\n"
+	print	"	power set tdp <number> : set the multiplier to given number and ONLY in decimals\n"
+	print	"	power set tdc <number> : set the multiplier to given number and ONLY in decimals\n"
+	print	"	power get : examine the current TDP / TDC\n"
+end
+
+def clock_command_list()
+	print "clock : allows for software clock modulation ( a form of throttling )\n"
+	print " a good link for understanding this is http://paulsiu.wordpress.com/2007/06/23/does-on-demand-clock-modulation-odcm-conserve-battery/\n"
+	print "   probable commands are\n"
+	print "	clock set <number> : set the number to one of the below or in range between 0-100\n"
+	print "		and i will automatically to the value nearest to\n"
+	print "		12.5, 25.0, 37.5, 50.0, 63.5, 75, 87.5  (nehalem)\n"
+	print "		sandy bridge supports 6.25% increments\n"
+	print "		but, I (the tool) is not smart yet to distinguish between nehalem and sb\n"
+	print "		so setting to 12.5 increment\n"
+	print " 	     set <number> to 1 for 12.5%, 2 for 25%, 3 for 37.5%, 4 for 50%, \n"
+	print"		5 for 63.5%, 6 for 75% and 7 for 87.5%\n"
+	print	"	clock status	    : get clock modulation status\n"
+	print	"	clock disable	    : disable clock modulation\n"
+end
+
+@duty_cycle_array = {0=>"reserved", 1=>'12.5% (default)', 2=>'25%', 3=>'37.5%', 4=>'50%', 5=>'63.5%',6=>'75%',7=>'87.5%'}
+
+def get_clock_status()
+	status = `rdmsr  0x19a --bitfield 4:4`
+	print_command('rdmsr  0x19a --bitfield 4:4')
+	if status.to_i == 0
+		print "Clock modulation is disabled\n"
+	else
+		print "Clock modulation is enabled\n"
+		status = `rdmsr  0x19a --bitfield 3:1`
+		print_command('rdmsr  0x19a --bitfield 3:1')
+		print "Duty Cycle is #{@duty_cycle_array[status.to_i]}\n"
+	end
+end
+
+def set_clock_modulation(mult)
+	if (mult.to_i<0) | (mult.to_i>8)
+		print "Error: clock set <number>, where <number> should be between 1-7\n"
+		print " 	     set <number> to 1 for 12.5%, 2 for 25%, 3 for 37.5%, 4 for 50%, \n"
+		print"		5 for 63.5%, 6 for 75% and 7 for 87.5%\n"
+		return
+	end
+	get_clock_status()
+
+	mult = mult.to_i << 1
+	mult = mult | 0x10
+	
+	for i in (0..12)
+		status = "wrmsr  0x19a -p#{i} #{mult}"
+		print_command(status)
+		system(status)
+	end
+	get_clock_status()
+end
+
+def clock_disable()
+	val = 0x0
+	for i in (0..(num_cores()*2-1))
+		status = "wrmsr  0x19a -p#{i} #{val}"
+		print_command(status)
+		system(status)
+	end
+	get_clock_status()
+end	
+
+def print_command( str )
+	print "Running following command in sudo:  #{str} \n"
+end
+
+def print_turbo_status()
+	status = `rdmsr  0x1a0 --bitfield 38:38`
+	print_command('rdmsr  0x1a0 --bitfield 38:38')
+	
+	if status.to_i == 1
+		print "Turbo is Disabled\n"
+	else
+		print "Turbo is Enabled\n"
+	end
+end
+
+def enable_turbo_status()
+	status = `rdmsr  0x1a0 --decimal`
+	print "First checking status\n"
+	print_command('rdmsr  0x1a0 --decimal')
+	
+	status = status.to_i & 0xBFFFFFFFFF #1 the 38th bit
+	
+	command = "wrmsr 0x1a0 #{status}"
+	system(command)
+	print_command(command)
+	
+	status = `rdmsr  0x1a0 --bitfield 38:38`
+	print "Now checking if the update was successful or not\n"
+	print_command('rdmsr  0x1a0 --bitfield 38:38')
+	
+	if status.to_i == 1
+		print "Turbo is now Disabled, command failed and i dont know whyq\n"
+	else
+		print "Turbo is now Enabled, command succeeded\n"
+	end
+end
+
+def disable_turbo_status()
+	status = `rdmsr  0x1a0 --decimal`
+	status = status.to_i | 0x4000000000 #1 the 38th bit
+	print "First checking status\n"
+	print_command('rdmsr  0x1a0 --decimal')
+	
+	command = "wrmsr 0x1a0 #{status}"
+	system(command)
+	print_command(command)
+	
+	status = `rdmsr  0x1a0 --bitfield 38:38`
+	print "Now checking if the update was successful or not\n"
+	print_command('rdmsr  0x1a0 --bitfield 38:38')
+
+	if status.to_i == 1
+		print "Turbo is now Disabled, command succeeded\n"
+	else
+		print "Turbo is now Enabled, command failed and i dont know why\n"
+	end
+end
+
+def get_multiplier()
+	if nehalem_or_sandybridge == 'Nehalem'
+	    status = `rdmsr  0x198 --decimal`
+	    print_command('rdmsr  0x198 --decimal')
+	    status = status.to_i & 0xFFFF
+	else
+	    status = `rdmsr  0x198 --decimal --bitfield 15:8`
+	    print_command('rdmsr  0x198 --decimal --bitfield 15:8')
+	    status = status.to_i & 0xFF
+	end
+	print "  Current Multiplier is #{status}\n"
+	
+	status1 = `rdmsr  0xce --decimal --bitfield 47:40`
+	print_command('rdmsr  0xce --decimal --bitfield 47:40')
+	print "  Minimum Multiplier possible is #{status1.chomp}\n"
+	
+	status1 = `rdmsr  0xce --decimal --bitfield 15:8`
+	print_command('rdmsr  0xce --decimal --bitfield 15:8')
+	print "  Maximum Multiplier in Non-turbo mode is #{status1.chomp}\n"
+	
+	turbo1 = `rdmsr  0x1ad --decimal --bitfield 7:0`
+	print_command('rdmsr  0x1ad --decimal --bitfield 7:0')
+	turbo2 = `rdmsr  0x1ad --decimal --bitfield 15:8`
+	print_command('rdmsr  0x1ad --decimal --bitfield 15:8')
+	turbo3 = `rdmsr  0x1ad --decimal --bitfield 23:16`
+	print_command('rdmsr  0x1ad --decimal --bitfield 23:16')
+	turbo4 = `rdmsr  0x1ad --decimal --bitfield 31:24`
+	print_command('rdmsr  0x1ad --decimal --bitfield 31:24')
+	turbo5 = `rdmsr  0x1ad --decimal --bitfield 39:32`
+	print_command('rdmsr  0x1ad --decimal --bitfield 39:32')
+	turbo6 = `rdmsr  0x1ad --decimal --bitfield 47:40`
+	print_command('rdmsr  0x1ad --decimal --bitfield 47:40')
+	
+	if num_cores()>=5
+		print "  Maximum turbo limit with 1/2/3/4/5/6 cores active is #{turbo1.chomp}/#{turbo2.chomp}/#{turbo3.chomp}/#{turbo4.chomp}/#{turbo5.chomp}/#{turbo6.chomp}\n"
+	elsif (num_cores()<=4 && num_cores()>2)
+			print "  Maximum turbo limit with 1/2/3/4 cores active is #{turbo1.chomp}/#{turbo2.chomp}/#{turbo3.chomp}/#{turbo4.chomp}\n"
+	else
+			print "  Maximum turbo limit with 1/2 cores active is #{turbo1.chomp}/#{turbo2.chomp}\n"
+	end
+end
+
+def set_multiplier(mult)
+	status1 = `rdmsr  0xce --decimal --bitfield 47:40`
+	minimum_multiplier = status1.chomp.to_i
+	print_command('rdmsr  0xce --decimal --bitfield 47:40')
+	
+	turbo1 = `rdmsr  0x1ad --decimal --bitfield 7:0`
+	maximum_multiplier = turbo1.chomp.to_i
+	print_command('rdmsr  0x1ad --decimal --bitfield 7:0')
+	
+	if (mult < minimum_multiplier) | (mult > maximum_multiplier)
+		print "You asked for a multiplier #{mult}\n"
+		print "The range of input Multiplier is not in range\n"
+		print "Please put it between #{minimum_multiplier} to #{maximum_multiplier}\n"
+
+	else
+		print "Don't worry if it prints that some wrmsr error message; i dont know the number of cores on your current machine so trying from 0..12"
+		for i in (0..(num_cores()*2-1))
+			status = "wrmsr  0x199 -p#{i} #{mult}"
+			print_command(status)
+			system(status)
+		end
+	end
+	
+	get_multiplier()
+	#print "Current Multiplier is #{status}\n"
+end
+
+def get_power
+	if nehalem_or_sandybridge != 'Nehalem'
+	    print "POWER functions DON'T WORK ON SANDY BRIDGE (intel seems to have removed functionality)\n"
+	else
+	    status1 = `rdmsr  0x1ac --bitfield 14:0 --decimal`
+	    print_command('rdmsr  0x1ac --bitfield 14:0 --decimal')
+	
+	    status2 = `rdmsr  0x1ac --bitfield 30:16 --decimal`
+	    print_command('rdmsr  0x1ac --bitfield 30:16 --decimal')
+	
+	    print "Current TDP limit is #{status1.to_i * 1/8} watts, TDC limit is #{status2.to_i * 1/8} amps\n"
+	end
+end	
+
+def set_tdp(limit)
+	if nehalem_or_sandybridge != 'Nehalem'
+	    print "POWER functions DON'T WORK ON SANDY BRIDGE (intel seems to have removed functionality)\n"
+	else
+	    status1 = `rdmsr  0x1ac --decimal`
+	    print_command('rdmsr  0x1ac --decimal')
+	
+	    tdp = (status1.to_i & 0xFFFFFFFFFFFF8000) | (0x8000) | (limit.to_i/0.125)  #set bits 14:0, as resolution is 1/8 of a watt/amp 
+	
+	    status = "wrmsr  0x1ac #{tdp}"
+	    print_command(status)
+	    system(status)	
+	end
+end
+
+def set_tdc(limit)
+	if nehalem_or_sandybridge != 'Nehalem'
+	    print "POWER functions DON'T WORK ON SANDY BRIDGE (intel seems to have removed functionality)\n"
+	else
+	    status1 = `rdmsr  0x1ac --decimal`
+	    print_command('rdmsr  0x1ac --decimal')
+	
+	    tdc = (status1.to_i & 0xFFFFFFFF8000FFFF) | (0x80000000) | ((limit.to_i/0.125).to_i << 16)  #set bits 30:16, as resolution is 1/8 of a watt/amp 
+	
+	    status = "wrmsr  0x1ac #{tdc}"
+	    print_command(status)
+	    system(status)	
+	end
+end
+
+
+#IGNORE THIS FUNCTION - NOT USING IT AT ALL
+def disable_ida()
+	#status = `rdmsr 0x199`
+	#status = status.to_i(16)
+	#p status
+	
+	#disable_turbo_string = 0x0100
+	#system("wrmsr 0x199 #{disable_turbo_string}")
+
+	#read the current opportunistic performance status and then write it. so first STATUS and then CTL
+	curr_status = `rdmsr 0x198 --decimal`
+	print  "current performance status 0x#{curr_status}\n"
+	curr_status = (curr_status.to_i | 0x100).to_s(16)
+	print  "in order to set ida=disable i will set bit 32 to get the following byte value 0x#{curr_status}\n"
+	curr_command = "wrmsr 0x199 #{curr_status}"
+	print "now executing #{curr_command}\n"
+	system(curr_command)
+end
+
+print "\n\nThis script is totally experimental \n"
+print "use it in superuser mode to get access to r/w access \n"
+print "also i need msr-tools installed so that rdmsr and wrmsr can work in sudo\n"
+print "write quit or ctrl+C to exit\n\n"
+print "Now for the blurb on why you might find this script useful:\n"
+print "Throttling cpu on battery is one place, some machines including W520\n"
+print "have a wierd bios which switches off turbo when machine is booted in\n"
+print "battery or some bios implement throttling even when the power is within limit\n"
+print "and this tool should allow you to manually set the multiplier\n"
+print "Whenever you run a command it will print out what goes in the background\n"
+print "like what registers were read/written etc, this should allow one to even\n"
+print "write different scripts to automatically run specifics multiplier in battery\n"
+print "power and other modes.\n"
+print "msr-tools are needed. Furthermore \"modprobe msr\" on command line needs to be executed\n"
+print_command_list()
+
+at_exit{print "exiting, thanks for using\n"}
+
+while(1)
+	print ">> "
+	$input = STDIN.gets.chomp
+	if $input.downcase.eql? "quit"
+		break;
+	end
+	
+	if $input.length == 0
+		print_command_list()
+	else 
+		commands = $input.split
+		case commands[0].downcase  # some commands have 0 level, eg just `help', others have two level 'turbo' and then status, enable and disable. multiplier get has 3 levels multiplier set 12 will set the multplier to 12
+			when "help"
+				print_command_list()
+			when "turbo"
+				if ! commands[1].nil?
+					case commands[1].downcase
+						when "status"
+							print_turbo_status()
+						when "enable"
+							enable_turbo_status()
+						when "disable"
+							disable_turbo_status()
+						else
+							turbo_command_list()
+					end
+				else
+					turbo_command_list()
+				end
+			when "multiplier"
+				if !commands[1].nil?
+					case commands[1].downcase
+						when "get"
+							get_multiplier()
+						when "set"
+							if !commands[2].nil?
+								set_multiplier(commands[2].to_i)
+							else
+								multiplier_command_list()
+							end
+						else
+							multiplier_command_list()
+					end
+				else
+					multiplier_command_list()
+				end			
+			when "power"
+				if !commands[1].nil?
+					case commands[1].downcase
+						when "get"
+							get_power()
+						when "set"
+							if !commands[2].nil?  && !commands[3].nil?
+								case commands[2].downcase
+									when "tdp"
+										set_tdp(commands[3])
+									when "tdc"
+										set_tdc(commands[3])
+									else
+										power_command_list()
+								end
+							else
+								power_command_list()
+							end
+						else
+							power_command_list()
+					end
+				else
+					power_command_list()
+				end	
+			when "clock"
+				if !commands[1].nil?
+					case commands[1].downcase
+						when "status"
+							get_clock_status()
+						when "set"
+							if !commands[2].nil?
+								set_clock_modulation(commands[2])
+							else
+								clock_command_list()
+							end
+						when "disable"
+							clock_disable()
+						else
+							clock_command_list()
+					end
+				else
+					clock_command_list()
+				end					
+            when "system"
+                print "number of cores #{num_cores()}\n"
+                print "trying to distinguish between nehalem/sandy bridge via AVX support... #{nehalem_or_sandybridge}\n"
+            else
+                print_command_list()
+		end
+	end
+	
+	
+end
+

=== removed file '.pc/install-i7z_rw_registers/Makefile'
--- .pc/install-i7z_rw_registers/Makefile	2013-03-16 21:16:14 +0000
+++ .pc/install-i7z_rw_registers/Makefile	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-#
-# Makefile for i7z, GPL v2, License in COPYING
-#
-
-#makefile updated from patch by anestling
-
-#explicitly disable two scheduling flags as they cause segfaults, two more seem to crash the GUI version so putting them
-#here 
-CFLAGS_FOR_AVOIDING_SEG_FAULT = -fno-schedule-insns2  -fno-schedule-insns -fno-inline-small-functions -fno-caller-saves
-CFLAGS ?= -O3
-CFLAGS += $(CFLAGS_FOR_AVOIDING_SEG_FAULT) -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -DBUILD_MAIN -Wimplicit-function-declaration
-
-LBITS := $(shell getconf LONG_BIT)
-ifeq ($(LBITS),64)
-   CFLAGS += -Dx64_BIT
-else
-   CFLAGS += -Dx86
-endif
-
-CC       ?= gcc
-
-LIBS  += -lncurses -lpthread -lrt -lm
-INCLUDEFLAGS = 
-
-BIN	= i7z
-# PERFMON-BIN = perfmon-i7z #future version to include performance monitor, either standalone or integrated
-SRC	= i7z.c helper_functions.c i7z_Single_Socket.c i7z_Dual_Socket.c
-OBJ	= $(SRC:.c=.o)
-
-prefix ?= /usr
-sbindir = $(prefix)/sbin/
-docdir = $(prefix)/share/doc/$(BIN)/
-mandir ?= $(prefix)/share/man/
-
-all: clean test_exist
-
-message:
-	@echo "If the compilation complains about not finding ncurses.h, install ncurses (libncurses5-dev on ubuntu/debian)"
-
-bin: message $(OBJ)
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $(BIN) $(OBJ) $(LIBS)
-
-#http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=644728 for -ltinfo on debian
-static-bin: message $(OBJ)
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $(BIN) $(OBJ) -static-libgcc -DNCURSES_STATIC -static -lpthread -lncurses -lrt -lm -ltinfo
-
-# perfmon-bin: message $(OBJ)
-# 	$(CC) $(CFLAGS) $(LDFLAGS) -o $(PERFMON-BIN) perfmon-i7z.c helper_functions.c $(LIBS)
-
-test_exist: bin
-	@test -f i7z && echo 'Succeeded, now run sudo ./i7z' || echo 'Compilation failed'
-
-clean:
-	rm -f *.o $(BIN)
-
-distclean: clean
-	rm -f *~ \#*
-
-install:  $(BIN)
-	install -D -m 0644 doc/i7z.man $(DESTDIR)$(mandir)man1/i7z.1
-	install -D -m 755 $(BIN) $(DESTDIR)$(sbindir)$(BIN)
-	install -d $(DESTDIR)$(docdir)
-	install -m 0644 README.txt put_cores_offline.sh put_cores_online.sh MAKEDEV-cpuid-msr $(DESTDIR)$(docdir)

=== removed file '.pc/install-i7z_rw_registers/i7z_rw_registers.rb'
--- .pc/install-i7z_rw_registers/i7z_rw_registers.rb	2013-03-16 21:16:14 +0000
+++ .pc/install-i7z_rw_registers/i7z_rw_registers.rb	1970-01-01 00:00:00 +0000
@@ -1,435 +0,0 @@
-#* ----------------------------------------------------------------------- *
-# *
-# *   Under GPL v3
-# *   written by Abhishek Jaiantilal
-# *   much thanks to Antonio Meireles who suggested this idea & helped with testing 
-# *   run as      sudo ruby i7z_rw_registers.rb
-# *
-# * ----------------------------------------------------------------------- */
-
-#!/usr/bin/ruby
-
-def print_command_list()
-	print "Do you need help? \n"
-	print "Possible commands are \n" 
-	print "help : which will print this list again \n"
-	print "turbo : which examines the turbo status \n"
-	print "multiplier : examines the multipliers \n"
-	print "power : which prints current wattage of the system\n"
-	print "clock : allows for software clock modulation ( a form of throttling )\n"
-    print "system : allows to print some system info\n"
-	print "quit : which will quit the program or just do ctrl + c\n"
-end
-
-IA32_PERF_STATUS =  0x198  	#read only
-IA32_PERF_CTL = 0x199  		#read write
-IA32_MISC_ENABLE = 0x1a0
-
-def num_cores 
-    numcores = `cat /proc/cpuinfo | grep 'cpu cores' |head -n 1|sed 's/cpu cores\\s*:\\s//'`
-    return numcores.to_i
-end
-
-def nehalem_or_sandybridge
-    proc_type = `cat /proc/cpuinfo | grep flags |head -n 1| grep avx`
-    
-    if proc_type.chomp.length == 0
-        return 'Nehalem'
-    else 
-        return 'Sandy Bridge'
-    end
-end
-
-def turbo_command_list()
-	print "turbo : which examines the turbo status \n"
-	print "   probable commands are\n"
-	print	"	turbo status : get the current status of turbo\n"
-	print	"	turbo enable : enable turbo\n"
-	print	"	turbo disable : disable turbo\n"
-end
-
-def multiplier_command_list()
-	print "multiplier : which allows setting/examining multiplier \n"
-	print "   probable commands are\n"
-	print	"	multiplier set <number> : set the multiplier to given number and ONLY in decimals\n"
-	print	"	multiplier get : examine the current multiplier\n"
-end
-
-def power_command_list()
-	print "power : which allows setting/examining TDP / TDC\n"
-	print "   probable commands are\n"
-	print	"	power set tdp <number> : set the multiplier to given number and ONLY in decimals\n"
-	print	"	power set tdc <number> : set the multiplier to given number and ONLY in decimals\n"
-	print	"	power get : examine the current TDP / TDC\n"
-end
-
-def clock_command_list()
-	print "clock : allows for software clock modulation ( a form of throttling )\n"
-	print " a good link for understanding this is http://paulsiu.wordpress.com/2007/06/23/does-on-demand-clock-modulation-odcm-conserve-battery/\n"
-	print "   probable commands are\n"
-	print "	clock set <number> : set the number to one of the below or in range between 0-100\n"
-	print "		and i will automatically to the value nearest to\n"
-	print "		12.5, 25.0, 37.5, 50.0, 63.5, 75, 87.5  (nehalem)\n"
-	print "		sandy bridge supports 6.25% increments\n"
-	print "		but, I (the tool) is not smart yet to distinguish between nehalem and sb\n"
-	print "		so setting to 12.5 increment\n"
-	print " 	     set <number> to 1 for 12.5%, 2 for 25%, 3 for 37.5%, 4 for 50%, \n"
-	print"		5 for 63.5%, 6 for 75% and 7 for 87.5%\n"
-	print	"	clock status	    : get clock modulation status\n"
-	print	"	clock disable	    : disable clock modulation\n"
-end
-
-@duty_cycle_array = {0=>"reserved", 1=>'12.5% (default)', 2=>'25%', 3=>'37.5%', 4=>'50%', 5=>'63.5%',6=>'75%',7=>'87.5%'}
-
-def get_clock_status()
-	status = `rdmsr  0x19a --bitfield 4:4`
-	print_command('rdmsr  0x19a --bitfield 4:4')
-	if status.to_i == 0
-		print "Clock modulation is disabled\n"
-	else
-		print "Clock modulation is enabled\n"
-		status = `rdmsr  0x19a --bitfield 3:1`
-		print_command('rdmsr  0x19a --bitfield 3:1')
-		print "Duty Cycle is #{@duty_cycle_array[status.to_i]}\n"
-	end
-end
-
-def set_clock_modulation(mult)
-	if (mult.to_i<0) | (mult.to_i>8)
-		print "Error: clock set <number>, where <number> should be between 1-7\n"
-		print " 	     set <number> to 1 for 12.5%, 2 for 25%, 3 for 37.5%, 4 for 50%, \n"
-		print"		5 for 63.5%, 6 for 75% and 7 for 87.5%\n"
-		return
-	end
-	get_clock_status()
-
-	mult = mult.to_i << 1
-	mult = mult | 0x10
-	
-	for i in (0..12)
-		status = "wrmsr  0x19a -p#{i} #{mult}"
-		print_command(status)
-		system(status)
-	end
-	get_clock_status()
-end
-
-def clock_disable()
-	val = 0x0
-	for i in (0..(num_cores()*2-1))
-		status = "wrmsr  0x19a -p#{i} #{val}"
-		print_command(status)
-		system(status)
-	end
-	get_clock_status()
-end	
-
-def print_command( str )
-	print "Running following command in sudo:  #{str} \n"
-end
-
-def print_turbo_status()
-	status = `rdmsr  0x1a0 --bitfield 38:38`
-	print_command('rdmsr  0x1a0 --bitfield 38:38')
-	
-	if status.to_i == 1
-		print "Turbo is Disabled\n"
-	else
-		print "Turbo is Enabled\n"
-	end
-end
-
-def enable_turbo_status()
-	status = `rdmsr  0x1a0 --decimal`
-	print "First checking status\n"
-	print_command('rdmsr  0x1a0 --decimal')
-	
-	status = status.to_i & 0xBFFFFFFFFF #1 the 38th bit
-	
-	command = "wrmsr 0x1a0 #{status}"
-	system(command)
-	print_command(command)
-	
-	status = `rdmsr  0x1a0 --bitfield 38:38`
-	print "Now checking if the update was successful or not\n"
-	print_command('rdmsr  0x1a0 --bitfield 38:38')
-	
-	if status.to_i == 1
-		print "Turbo is now Disabled, command failed and i dont know whyq\n"
-	else
-		print "Turbo is now Enabled, command succeeded\n"
-	end
-end
-
-def disable_turbo_status()
-	status = `rdmsr  0x1a0 --decimal`
-	status = status.to_i | 0x4000000000 #1 the 38th bit
-	print "First checking status\n"
-	print_command('rdmsr  0x1a0 --decimal')
-	
-	command = "wrmsr 0x1a0 #{status}"
-	system(command)
-	print_command(command)
-	
-	status = `rdmsr  0x1a0 --bitfield 38:38`
-	print "Now checking if the update was successful or not\n"
-	print_command('rdmsr  0x1a0 --bitfield 38:38')
-
-	if status.to_i == 1
-		print "Turbo is now Disabled, command succeeded\n"
-	else
-		print "Turbo is now Enabled, command failed and i dont know why\n"
-	end
-end
-
-def get_multiplier()
-	if nehalem_or_sandybridge == 'Nehalem'
-	    status = `rdmsr  0x198 --decimal`
-	    print_command('rdmsr  0x198 --decimal')
-	    status = status.to_i & 0xFFFF
-	else
-	    status = `rdmsr  0x198 --decimal --bitfield 15:8`
-	    print_command('rdmsr  0x198 --decimal --bitfield 15:8')
-	    status = status.to_i & 0xFF
-	end
-	print "  Current Multiplier is #{status}\n"
-	
-	status1 = `rdmsr  0xce --decimal --bitfield 47:40`
-	print_command('rdmsr  0xce --decimal --bitfield 47:40')
-	print "  Minimum Multiplier possible is #{status1.chomp}\n"
-	
-	status1 = `rdmsr  0xce --decimal --bitfield 15:8`
-	print_command('rdmsr  0xce --decimal --bitfield 15:8')
-	print "  Maximum Multiplier in Non-turbo mode is #{status1.chomp}\n"
-	
-	turbo1 = `rdmsr  0x1ad --decimal --bitfield 7:0`
-	print_command('rdmsr  0x1ad --decimal --bitfield 7:0')
-	turbo2 = `rdmsr  0x1ad --decimal --bitfield 15:8`
-	print_command('rdmsr  0x1ad --decimal --bitfield 15:8')
-	turbo3 = `rdmsr  0x1ad --decimal --bitfield 23:16`
-	print_command('rdmsr  0x1ad --decimal --bitfield 23:16')
-	turbo4 = `rdmsr  0x1ad --decimal --bitfield 31:24`
-	print_command('rdmsr  0x1ad --decimal --bitfield 31:24')
-	turbo5 = `rdmsr  0x1ad --decimal --bitfield 39:32`
-	print_command('rdmsr  0x1ad --decimal --bitfield 39:32')
-	turbo6 = `rdmsr  0x1ad --decimal --bitfield 47:40`
-	print_command('rdmsr  0x1ad --decimal --bitfield 47:40')
-	
-	if num_cores()>=5
-		print "  Maximum turbo limit with 1/2/3/4/5/6 cores active is #{turbo1.chomp}/#{turbo2.chomp}/#{turbo3.chomp}/#{turbo4.chomp}/#{turbo5.chomp}/#{turbo6.chomp}\n"
-	elsif (num_cores()<=4 && num_cores()>2)
-			print "  Maximum turbo limit with 1/2/3/4 cores active is #{turbo1.chomp}/#{turbo2.chomp}/#{turbo3.chomp}/#{turbo4.chomp}\n"
-	else
-			print "  Maximum turbo limit with 1/2 cores active is #{turbo1.chomp}/#{turbo2.chomp}\n"
-	end
-end
-
-def set_multiplier(mult)
-	status1 = `rdmsr  0xce --decimal --bitfield 47:40`
-	minimum_multiplier = status1.chomp.to_i
-	print_command('rdmsr  0xce --decimal --bitfield 47:40')
-	
-	turbo1 = `rdmsr  0x1ad --decimal --bitfield 7:0`
-	maximum_multiplier = turbo1.chomp.to_i
-	print_command('rdmsr  0x1ad --decimal --bitfield 7:0')
-	
-	if (mult < minimum_multiplier) | (mult > maximum_multiplier)
-		print "You asked for a multiplier #{mult}\n"
-		print "The range of input Multiplier is not in range\n"
-		print "Please put it between #{minimum_multiplier} to #{maximum_multiplier}\n"
-
-	else
-		print "Don't worry if it prints that some wrmsr error message; i dont know the number of cores on your current machine so trying from 0..12"
-		for i in (0..(num_cores()*2-1))
-			status = "wrmsr  0x199 -p#{i} #{mult}"
-			print_command(status)
-			system(status)
-		end
-	end
-	
-	get_multiplier()
-	#print "Current Multiplier is #{status}\n"
-end
-
-def get_power
-	if nehalem_or_sandybridge != 'Nehalem'
-	    print "POWER functions DON'T WORK ON SANDY BRIDGE (intel seems to have removed functionality)\n"
-	else
-	    status1 = `rdmsr  0x1ac --bitfield 14:0 --decimal`
-	    print_command('rdmsr  0x1ac --bitfield 14:0 --decimal')
-	
-	    status2 = `rdmsr  0x1ac --bitfield 30:16 --decimal`
-	    print_command('rdmsr  0x1ac --bitfield 30:16 --decimal')
-	
-	    print "Current TDP limit is #{status1.to_i * 1/8} watts, TDC limit is #{status2.to_i * 1/8} amps\n"
-	end
-end	
-
-def set_tdp(limit)
-	if nehalem_or_sandybridge != 'Nehalem'
-	    print "POWER functions DON'T WORK ON SANDY BRIDGE (intel seems to have removed functionality)\n"
-	else
-	    status1 = `rdmsr  0x1ac --decimal`
-	    print_command('rdmsr  0x1ac --decimal')
-	
-	    tdp = (status1.to_i & 0xFFFFFFFFFFFF8000) | (0x8000) | (limit.to_i/0.125)  #set bits 14:0, as resolution is 1/8 of a watt/amp 
-	
-	    status = "wrmsr  0x1ac #{tdp}"
-	    print_command(status)
-	    system(status)	
-	end
-end
-
-def set_tdc(limit)
-	if nehalem_or_sandybridge != 'Nehalem'
-	    print "POWER functions DON'T WORK ON SANDY BRIDGE (intel seems to have removed functionality)\n"
-	else
-	    status1 = `rdmsr  0x1ac --decimal`
-	    print_command('rdmsr  0x1ac --decimal')
-	
-	    tdc = (status1.to_i & 0xFFFFFFFF8000FFFF) | (0x80000000) | ((limit.to_i/0.125).to_i << 16)  #set bits 30:16, as resolution is 1/8 of a watt/amp 
-	
-	    status = "wrmsr  0x1ac #{tdc}"
-	    print_command(status)
-	    system(status)	
-	end
-end
-
-
-#IGNORE THIS FUNCTION - NOT USING IT AT ALL
-def disable_ida()
-	#status = `rdmsr 0x199`
-	#status = status.to_i(16)
-	#p status
-	
-	#disable_turbo_string = 0x0100
-	#system("wrmsr 0x199 #{disable_turbo_string}")
-
-	#read the current opportunistic performance status and then write it. so first STATUS and then CTL
-	curr_status = `rdmsr 0x198 --decimal`
-	print  "current performance status 0x#{curr_status}\n"
-	curr_status = (curr_status.to_i | 0x100).to_s(16)
-	print  "in order to set ida=disable i will set bit 32 to get the following byte value 0x#{curr_status}\n"
-	curr_command = "wrmsr 0x199 #{curr_status}"
-	print "now executing #{curr_command}\n"
-	system(curr_command)
-end
-
-print "\n\nThis script is totally experimental \n"
-print "use it in superuser mode to get access to r/w access \n"
-print "also i need msr-tools installed so that rdmsr and wrmsr can work in sudo\n"
-print "write quit or ctrl+C to exit\n\n"
-print "Now for the blurb on why you might find this script useful:\n"
-print "Throttling cpu on battery is one place, some machines including W520\n"
-print "have a wierd bios which switches off turbo when machine is booted in\n"
-print "battery or some bios implement throttling even when the power is within limit\n"
-print "and this tool should allow you to manually set the multiplier\n"
-print "Whenever you run a command it will print out what goes in the background\n"
-print "like what registers were read/written etc, this should allow one to even\n"
-print "write different scripts to automatically run specifics multiplier in battery\n"
-print "power and other modes.\n"
-print "msr-tools are needed. Furthermore \"modprobe msr\" on command line needs to be executed\n"
-print_command_list()
-
-at_exit{print "exiting, thanks for using\n"}
-
-while(1)
-	print ">> "
-	$input = STDIN.gets.chomp
-	if $input.downcase.eql? "quit"
-		break;
-	end
-	
-	if $input.length == 0
-		print_command_list()
-	else 
-		commands = $input.split
-		case commands[0].downcase  # some commands have 0 level, eg just `help', others have two level 'turbo' and then status, enable and disable. multiplier get has 3 levels multiplier set 12 will set the multplier to 12
-			when "help"
-				print_command_list()
-			when "turbo"
-				if ! commands[1].nil?
-					case commands[1].downcase
-						when "status"
-							print_turbo_status()
-						when "enable"
-							enable_turbo_status()
-						when "disable"
-							disable_turbo_status()
-						else
-							turbo_command_list()
-					end
-				else
-					turbo_command_list()
-				end
-			when "multiplier"
-				if !commands[1].nil?
-					case commands[1].downcase
-						when "get"
-							get_multiplier()
-						when "set"
-							if !commands[2].nil?
-								set_multiplier(commands[2].to_i)
-							else
-								multiplier_command_list()
-							end
-						else
-							multiplier_command_list()
-					end
-				else
-					multiplier_command_list()
-				end			
-			when "power"
-				if !commands[1].nil?
-					case commands[1].downcase
-						when "get"
-							get_power()
-						when "set"
-							if !commands[2].nil?  && !commands[3].nil?
-								case commands[2].downcase
-									when "tdp"
-										set_tdp(commands[3])
-									when "tdc"
-										set_tdc(commands[3])
-									else
-										power_command_list()
-								end
-							else
-								power_command_list()
-							end
-						else
-							power_command_list()
-					end
-				else
-					power_command_list()
-				end	
-			when "clock"
-				if !commands[1].nil?
-					case commands[1].downcase
-						when "status"
-							get_clock_status()
-						when "set"
-							if !commands[2].nil?
-								set_clock_modulation(commands[2])
-							else
-								clock_command_list()
-							end
-						when "disable"
-							clock_disable()
-						else
-							clock_command_list()
-					end
-				else
-					clock_command_list()
-				end					
-            when "system"
-                print "number of cores #{num_cores()}\n"
-                print "trying to distinguish between nehalem/sandy bridge via AVX support... #{nehalem_or_sandybridge}\n"
-            else
-                print_command_list()
-		end
-	end
-	
-	
-end
-

=== modified file 'GUI/i7z_GUI.cpp'
--- GUI/i7z_GUI.cpp	2013-03-16 21:16:14 +0000
+++ GUI/i7z_GUI.cpp	2013-08-15 05:58:18 +0000
@@ -171,18 +171,17 @@
     //CPUINFO is wrong for i7 but correct for the number of physical and logical cores present
     //If Hyperthreading is enabled then, multiple logical processors will share a common CORE ID
     //http://www.redhat.com/magazine/022aug06/departments/tips_tricks/
-    system ("cat /proc/cpuinfo |grep MHz|sed 's/cpu\\sMHz\\s*:\\s//'|tail -n 1 > /tmp/cpufreq.txt");
-    system ("grep \"core id\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numPhysical.txt");
-    system ("grep \"processor\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numLogical.txt");
-
-
-    //Open the parsed cpufreq file and obtain the cpufreq from /proc/cpuinfo
+    //system ("grep \"core id\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numPhysical.txt");
+    //system ("grep \"processor\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numLogical.txt");
+
+
+    // obtain the cpufreq from /proc/cpuinfo
     FILE *tmp_file;
-    tmp_file = fopen ("/tmp/cpufreq.txt", "r");
+    tmp_file = popen ("sed -n '/MHz/ { s/cpu\\sMHz\\s*:\\s//p; q }' /proc/cpuinfo", "r");
     char tmp_str[30];
     fgets (tmp_str, 30, tmp_file);
+    pclose (tmp_file);
     double cpu_freq_cpuinfo = atof (tmp_str);
-    fclose (tmp_file);
 
     unsigned int numPhysicalCores, numLogicalCores;
     numPhysicalCores = socket_0.num_physical_cores + socket_1.num_physical_cores;

=== modified file 'debian/changelog'
--- debian/changelog	2013-04-29 09:37:19 +0000
+++ debian/changelog	2013-08-15 05:58:18 +0000
@@ -1,3 +1,19 @@
+i7z (0.27.2-2ubuntu1) saucy; urgency=low
+
+  * Merge from debian unstable. Remaining changes:
+    - debian/control: Future-proof by adding x32 to the architecture list
+
+ -- Jackson Doak <[e-mail]>  Thu, 15 Aug 2013 07:44:30 +1000
+
+i7z (0.27.2-2) unstable; urgency=low
+
+  * Use canonical Vcs-* URLs.
+  * hyphen-used-as-minus-sign.patch: New. Fix manpage.
+  * fix-insecure-tempfile.patch: New. Fix insecure usage of /tmp/cpufreq.txt.
+    Use popen() instead of a temporary file.  (Closes: #718418)
+
+ -- Andreas Beckmann <[e-mail]>  Thu, 01 Aug 2013 03:16:07 +0200
+
 i7z (0.27.2-1ubuntu1) saucy; urgency=low
 
   * Future-proof by adding x32 to the architecture list.

=== modified file 'debian/control'
--- debian/control	2013-04-29 09:37:19 +0000
+++ debian/control	2013-08-15 05:58:18 +0000
@@ -9,8 +9,8 @@
  gdb,
 Standards-Version: 3.9.4
 Homepage: http://code.google.com/p/i7z/
-Vcs-Git: git://git.debian.org/collab-maint/i7z.git
-Vcs-Browser: http://git.debian.org/?p=collab-maint/i7z.git;a=summary
+Vcs-Git: git://anonscm.debian.org/collab-maint/i7z.git
+Vcs-Browser: http://anonscm.debian.org/gitweb/?p=collab-maint/i7z.git;a=summary
 
 Package: i7z
 Architecture: amd64 i386 x32

=== added file 'debian/patches/fix-insecure-tempfile.patch'
--- debian/patches/fix-insecure-tempfile.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix-insecure-tempfile.patch	2013-08-15 05:58:18 +0000
@@ -0,0 +1,76 @@
+Author: Andreas Beckmann <[e-mail]>
+Description: fix insecure temfile usage: /tmp/cpufreq.txt
+ switch from system() + fopen() to popen()
+ disable other insecure tempfiles that may be generated but not used
+Bug-Debian: http://bugs.debian.org/718418
+
+Index: i7z/GUI/i7z_GUI.cpp
+===================================================================
+--- i7z.orig/GUI/i7z_GUI.cpp	2013-08-15 07:42:57.277752286 +1000
++++ i7z/GUI/i7z_GUI.cpp	2013-08-15 07:42:57.273752266 +1000
+@@ -171,18 +171,17 @@
+     //CPUINFO is wrong for i7 but correct for the number of physical and logical cores present
+     //If Hyperthreading is enabled then, multiple logical processors will share a common CORE ID
+     //http://www.redhat.com/magazine/022aug06/departments/tips_tricks/
+-    system ("cat /proc/cpuinfo |grep MHz|sed 's/cpu\\sMHz\\s*:\\s//'|tail -n 1 > /tmp/cpufreq.txt");
+-    system ("grep \"core id\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numPhysical.txt");
+-    system ("grep \"processor\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numLogical.txt");
++    //system ("grep \"core id\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numPhysical.txt");
++    //system ("grep \"processor\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numLogical.txt");
+ 
+ 
+-    //Open the parsed cpufreq file and obtain the cpufreq from /proc/cpuinfo
++    // obtain the cpufreq from /proc/cpuinfo
+     FILE *tmp_file;
+-    tmp_file = fopen ("/tmp/cpufreq.txt", "r");
++    tmp_file = popen ("sed -n '/MHz/ { s/cpu\\sMHz\\s*:\\s//p; q }' /proc/cpuinfo", "r");
+     char tmp_str[30];
+     fgets (tmp_str, 30, tmp_file);
++    pclose (tmp_file);
+     double cpu_freq_cpuinfo = atof (tmp_str);
+-    fclose (tmp_file);
+ 
+     unsigned int numPhysicalCores, numLogicalCores;
+     numPhysicalCores = socket_0.num_physical_cores + socket_1.num_physical_cores;
+Index: i7z/helper_functions.c
+===================================================================
+--- i7z.orig/helper_functions.c	2013-08-15 07:42:57.277752286 +1000
++++ i7z/helper_functions.c	2013-08-15 07:42:57.273752266 +1000
+@@ -531,16 +531,13 @@
+     //CPUINFO is wrong for i7 but correct for the number of physical and logical cores present
+     //If Hyperthreading is enabled then, multiple logical processors will share a common CORE ID
+     //http://www.redhat.com/magazine/022aug06/departments/tips_tricks/
+-    system
+-    ("cat /proc/cpuinfo |grep MHz|sed 's/cpu\\sMHz\\s*:\\s//'|tail -n 1 > /tmp/cpufreq.txt");
+ 
+-
+-    //Open the parsed cpufreq file and obtain the cpufreq from /proc/cpuinfo
++    // obtain the cpufreq from /proc/cpuinfo
+     FILE *tmp_file;
+-    tmp_file = fopen ("/tmp/cpufreq.txt", "r");
++    tmp_file = popen ("sed -n '/MHz/ { s/cpu\\sMHz\\s*:\\s//p; q }' /proc/cpuinfo", "r");
+     char tmp_str[30];
+     fgets (tmp_str, 30, tmp_file);
+-    fclose (tmp_file);
++    pclose (tmp_file);
+     return atof(tmp_str);
+ }
+ 
+Index: i7z/i7z_Single_Socket.c
+===================================================================
+--- i7z.orig/i7z_Single_Socket.c	2013-08-15 07:42:57.277752286 +1000
++++ i7z/i7z_Single_Socket.c	2013-08-15 07:42:57.273752266 +1000
+@@ -823,10 +823,13 @@
+ 	  //CPUINFO is wrong for i7 but correct for the number of physical and logical cores present
+ 	  //If Hyperthreading is enabled then, multiple logical processors will share a common CORE ID
+ 	  //http://www.redhat.com/magazine/022aug06/departments/tips_tricks/
++ERROR INSECURE TMPFILE
+ 	  system
+ 		("cat /proc/cpuinfo |grep MHz|sed 's/cpu\\sMHz\\s*:\\s//'|tail -n 1 > /tmp/cpufreq.txt");
++ERROR INSECURE TMPFILE
+ 	  system
+ 		("grep \"core id\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numPhysical.txt");
++ERROR INSECURE TMPFILE
+ 	  system
+ 		("grep \"processor\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numLogical.txt");
+ 	  //At this step, /tmp/numPhysical contains number of physical cores in machine and

=== added file 'debian/patches/hyphen-used-as-minus-sign.patch'
--- debian/patches/hyphen-used-as-minus-sign.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/hyphen-used-as-minus-sign.patch	2013-08-15 05:58:18 +0000
@@ -0,0 +1,28 @@
+Author: Andreas Beckmann <[e-mail]>
+Description: fix hyphen abuse
+
+Index: i7z/doc/i7z.man
+===================================================================
+--- i7z.orig/doc/i7z.man	2013-08-15 07:42:55.025741119 +1000
++++ i7z/doc/i7z.man	2013-08-15 07:42:55.025741119 +1000
+@@ -7,15 +7,15 @@
+ i7z runs the i7z, ncurses based, program without any options. i7z will print out the C-states and temperature for i3, i5 and i7 based Core processors from Intel (including Nehalems, Sandy Bridge and Ivy Bridge). 
+ .SH OPTIONS
+ .TP
+-\fB-h, --help \fPshow the list of options available with the i7z tool.
++\fB\-h, \-\-help \fPshow the list of options available with the i7z tool.
+ .TP
+-\fB-w  [a|l],  --write  [a,l] \fPLogging of the frequencies can be turned on with this options. Option "-w a" or "--write a" will append to the  log file. Option "-w l" or "--write l" will replace the log file.
++\fB\-w  [a|l],  \-\-write  [a,l] \fPLogging of the frequencies can be turned on with this options. Option "\-w a" or "\-\-write a" will append to the  log file. Option "\-w l" or "\-\-write l" will replace the log file.
+ .TP
+-\fB-l,  --logfile  [FILENAME] \fPChange  the  log file name to the specified FILENAME. Default logging file is cpu_freq_log.txt (single  socket) or cpu_freq_log_dual%d.txt (dual socket, %d is either 0, 1).
++\fB\-l,  \-\-logfile  [FILENAME] \fPChange  the  log file name to the specified FILENAME. Default logging file is cpu_freq_log.txt (single  socket) or cpu_freq_log_dual%d.txt (dual socket, %d is either 0, 1).
+ .TP
+-\fB--socket0  [SOCKETNUM], --socket1 [SOCKETNUM] \fPThe tool can print information for about 2 sockets at once at the most. The top view  will  be, by  default, of the first socket (controlled by --socket0) and the bottom view will be of the second socket (controlled by --socket1). Supply the appropriate value of 0 or 1 or more for SOCKETNUM (if there are more sockets on the machine) to show in the top and bottom view.
++\fB\-\-socket0  [SOCKETNUM], \-\-socket1 [SOCKETNUM] \fPThe tool can print information for about 2 sockets at once at the most. The top view  will  be, by  default, of the first socket (controlled by \-\-socket0) and the bottom view will be of the second socket (controlled by \-\-socket1). Supply the appropriate value of 0 or 1 or more for SOCKETNUM (if there are more sockets on the machine) to show in the top and bottom view.
+ .TP
+-\fB--nogui \fPDisable the GUI. Useful when the only need is logging.
++\fB\-\-nogui \fPDisable the GUI. Useful when the only need is logging.
+ .SH Example
+ To print for two sockets and also change the log file (log to /tmp/logfilei7z)
+ 

=== removed file 'debian/patches/install-i7z_rw_registers'
--- debian/patches/install-i7z_rw_registers	2013-03-16 21:16:14 +0000
+++ debian/patches/install-i7z_rw_registers	1970-01-01 00:00:00 +0000
@@ -1,26 +0,0 @@
-Author: Andreas Beckmann <[e-mail]>
-Description: install the i7z_rw_registers script and fix the hashbang
-
---- a/i7z_rw_registers.rb
-+++ b/i7z_rw_registers.rb
-@@ -1,3 +1,5 @@
-+#!/usr/bin/ruby
-+
- #* ----------------------------------------------------------------------- *
- # *
- # *   Under GPL v3
-@@ -7,7 +9,6 @@
- # *
- # * ----------------------------------------------------------------------- */
- 
--#!/usr/bin/ruby
- 
- def print_command_list()
- 	print "Do you need help? \n"
---- a/Makefile
-+++ b/Makefile
-@@ -61,3 +61,4 @@
- 	install -D -m 755 $(BIN) $(DESTDIR)$(sbindir)$(BIN)
- 	install -d $(DESTDIR)$(docdir)
- 	install -m 0644 README.txt put_cores_offline.sh put_cores_online.sh MAKEDEV-cpuid-msr $(DESTDIR)$(docdir)
-+	install -m 0755 i7z_rw_registers.rb $(DESTDIR)$(sbindir)/i7z_rw_registers

=== added file 'debian/patches/install-i7z_rw_registers.patch'
--- debian/patches/install-i7z_rw_registers.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/install-i7z_rw_registers.patch	2013-08-15 05:58:18 +0000
@@ -0,0 +1,30 @@
+Author: Andreas Beckmann <[e-mail]>
+Description: install the i7z_rw_registers script and fix the hashbang
+
+Index: i7z/i7z_rw_registers.rb
+===================================================================
+--- i7z.orig/i7z_rw_registers.rb	2013-08-15 07:42:49.797715195 +1000
++++ i7z/i7z_rw_registers.rb	2013-08-15 07:42:49.793715175 +1000
+@@ -1,3 +1,5 @@
++#!/usr/bin/ruby
++
+ #* ----------------------------------------------------------------------- *
+ # *
+ # *   Under GPL v3
+@@ -7,7 +9,6 @@
+ # *
+ # * ----------------------------------------------------------------------- */
+ 
+-#!/usr/bin/ruby
+ 
+ def print_command_list()
+ 	print "Do you need help? \n"
+Index: i7z/Makefile
+===================================================================
+--- i7z.orig/Makefile	2013-08-15 07:42:49.797715195 +1000
++++ i7z/Makefile	2013-08-15 07:42:49.793715175 +1000
+@@ -61,3 +61,4 @@
+ 	install -D -m 755 $(BIN) $(DESTDIR)$(sbindir)$(BIN)
+ 	install -d $(DESTDIR)$(docdir)
+ 	install -m 0644 README.txt put_cores_offline.sh put_cores_online.sh MAKEDEV-cpuid-msr $(DESTDIR)$(docdir)
++	install -m 0755 i7z_rw_registers.rb $(DESTDIR)$(sbindir)/i7z_rw_registers

=== modified file 'debian/patches/series'
--- debian/patches/series	2013-03-16 21:16:14 +0000
+++ debian/patches/series	2013-08-15 05:58:18 +0000
@@ -1,1 +1,3 @@
-install-i7z_rw_registers
+install-i7z_rw_registers.patch
+hyphen-used-as-minus-sign.patch
+fix-insecure-tempfile.patch

=== modified file 'debian/watch'
--- debian/watch	2013-03-16 21:16:14 +0000
+++ debian/watch	2013-08-15 05:58:18 +0000
@@ -1,3 +1,2 @@
 version=3
-
 http://code.google.com/p/i7z/downloads/list?can=1 .*/i7z-(\d[\d.]*)\.(?:zip|tgz|tbz2|txz|tar\.gz|tar\.bz2|tar\.xz)

=== modified file 'doc/i7z.man'
--- doc/i7z.man	2013-03-16 21:16:14 +0000
+++ doc/i7z.man	2013-08-15 05:58:18 +0000
@@ -7,15 +7,15 @@
 i7z runs the i7z, ncurses based, program without any options. i7z will print out the C-states and temperature for i3, i5 and i7 based Core processors from Intel (including Nehalems, Sandy Bridge and Ivy Bridge). 
 .SH OPTIONS
 .TP
-\fB-h, --help \fPshow the list of options available with the i7z tool.
-.TP
-\fB-w  [a|l],  --write  [a,l] \fPLogging of the frequencies can be turned on with this options. Option "-w a" or "--write a" will append to the  log file. Option "-w l" or "--write l" will replace the log file.
-.TP
-\fB-l,  --logfile  [FILENAME] \fPChange  the  log file name to the specified FILENAME. Default logging file is cpu_freq_log.txt (single  socket) or cpu_freq_log_dual%d.txt (dual socket, %d is either 0, 1).
-.TP
-\fB--socket0  [SOCKETNUM], --socket1 [SOCKETNUM] \fPThe tool can print information for about 2 sockets at once at the most. The top view  will  be, by  default, of the first socket (controlled by --socket0) and the bottom view will be of the second socket (controlled by --socket1). Supply the appropriate value of 0 or 1 or more for SOCKETNUM (if there are more sockets on the machine) to show in the top and bottom view.
-.TP
-\fB--nogui \fPDisable the GUI. Useful when the only need is logging.
+\fB\-h, \-\-help \fPshow the list of options available with the i7z tool.
+.TP
+\fB\-w  [a|l],  \-\-write  [a,l] \fPLogging of the frequencies can be turned on with this options. Option "\-w a" or "\-\-write a" will append to the  log file. Option "\-w l" or "\-\-write l" will replace the log file.
+.TP
+\fB\-l,  \-\-logfile  [FILENAME] \fPChange  the  log file name to the specified FILENAME. Default logging file is cpu_freq_log.txt (single  socket) or cpu_freq_log_dual%d.txt (dual socket, %d is either 0, 1).
+.TP
+\fB\-\-socket0  [SOCKETNUM], \-\-socket1 [SOCKETNUM] \fPThe tool can print information for about 2 sockets at once at the most. The top view  will  be, by  default, of the first socket (controlled by \-\-socket0) and the bottom view will be of the second socket (controlled by \-\-socket1). Supply the appropriate value of 0 or 1 or more for SOCKETNUM (if there are more sockets on the machine) to show in the top and bottom view.
+.TP
+\fB\-\-nogui \fPDisable the GUI. Useful when the only need is logging.
 .SH Example
 To print for two sockets and also change the log file (log to /tmp/logfilei7z)
 

=== modified file 'helper_functions.c'
--- helper_functions.c	2013-03-16 21:16:14 +0000
+++ helper_functions.c	2013-08-15 05:58:18 +0000
@@ -531,16 +531,13 @@
     //CPUINFO is wrong for i7 but correct for the number of physical and logical cores present
     //If Hyperthreading is enabled then, multiple logical processors will share a common CORE ID
     //http://www.redhat.com/magazine/022aug06/departments/tips_tricks/
-    system
-    ("cat /proc/cpuinfo |grep MHz|sed 's/cpu\\sMHz\\s*:\\s//'|tail -n 1 > /tmp/cpufreq.txt");
-
-
-    //Open the parsed cpufreq file and obtain the cpufreq from /proc/cpuinfo
+
+    // obtain the cpufreq from /proc/cpuinfo
     FILE *tmp_file;
-    tmp_file = fopen ("/tmp/cpufreq.txt", "r");
+    tmp_file = popen ("sed -n '/MHz/ { s/cpu\\sMHz\\s*:\\s//p; q }' /proc/cpuinfo", "r");
     char tmp_str[30];
     fgets (tmp_str, 30, tmp_file);
-    fclose (tmp_file);
+    pclose (tmp_file);
     return atof(tmp_str);
 }
 

=== modified file 'i7z_Single_Socket.c'
--- i7z_Single_Socket.c	2013-03-16 21:16:14 +0000
+++ i7z_Single_Socket.c	2013-08-15 05:58:18 +0000
@@ -823,10 +823,13 @@
 	  //CPUINFO is wrong for i7 but correct for the number of physical and logical cores present
 	  //If Hyperthreading is enabled then, multiple logical processors will share a common CORE ID
 	  //http://www.redhat.com/magazine/022aug06/departments/tips_tricks/
+ERROR INSECURE TMPFILE
 	  system
 		("cat /proc/cpuinfo |grep MHz|sed 's/cpu\\sMHz\\s*:\\s//'|tail -n 1 > /tmp/cpufreq.txt");
+ERROR INSECURE TMPFILE
 	  system
 		("grep \"core id\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numPhysical.txt");
+ERROR INSECURE TMPFILE
 	  system
 		("grep \"processor\" /proc/cpuinfo |sort -|uniq -|wc -l > /tmp/numLogical.txt");
 	  //At this step, /tmp/numPhysical contains number of physical cores in machine and