Hi Srinivasan,

I love your patch! Yet something to improve:

[auto build test ERROR on v4.17-rc3]
[also build test ERROR on next-20180504]
[cannot apply to tip/x86/core]
[if your patch is applied to the wrong git tree, please drop us a note to help 
improve the system]

url:    
https://github.com/0day-ci/linux/commits/kys-linuxonhyperv-com/X86-Hyper-V-APIC-enlightenments/20180505-045627
config: x86_64-randconfig-a0-05050447 (attached as .config)
compiler: gcc-7 (Debian 7.3.0-16) 7.3.0
reproduce:
        # save the attached .config to linux build tree
        make ARCH=x86_64 

All errors (new ones prefixed by >>):

   arch/x86/hyperv/hv_apic.c: In function 'hv_apic_read':
   arch/x86/hyperv/hv_apic.c:69:10: error: implicit declaration of function 
'native_apic_mem_read'; did you mean 'hv_apic_icr_read'? 
[-Werror=implicit-function-declaration]
      return native_apic_mem_read(reg);
             ^~~~~~~~~~~~~~~~~~~~
             hv_apic_icr_read
   arch/x86/hyperv/hv_apic.c: In function 'hv_apic_write':
   arch/x86/hyperv/hv_apic.c:83:3: error: implicit declaration of function 
'native_apic_mem_write'; did you mean 'hv_apic_icr_write'? 
[-Werror=implicit-function-declaration]
      native_apic_mem_write(reg, val);
      ^~~~~~~~~~~~~~~~~~~~~
      hv_apic_icr_write
   arch/x86/hyperv/hv_apic.c: In function 'hv_send_ipi':
>> arch/x86/hyperv/hv_apic.c:153:12: error: invalid use of undefined type 
>> 'struct apic'
      orig_apic.send_IPI(cpu, vector);
               ^
   arch/x86/hyperv/hv_apic.c: In function 'hv_send_ipi_mask':
   arch/x86/hyperv/hv_apic.c:159:12: error: invalid use of undefined type 
'struct apic'
      orig_apic.send_IPI_mask(mask, vector);
               ^
   arch/x86/hyperv/hv_apic.c: In function 'hv_send_ipi_mask_allbutself':
   arch/x86/hyperv/hv_apic.c:172:12: error: invalid use of undefined type 
'struct apic'
      orig_apic.send_IPI_mask_allbutself(mask, vector);
               ^
   arch/x86/hyperv/hv_apic.c: In function 'hv_send_ipi_all':
   arch/x86/hyperv/hv_apic.c:183:12: error: invalid use of undefined type 
'struct apic'
      orig_apic.send_IPI_all(vector);
               ^
   arch/x86/hyperv/hv_apic.c: In function 'hv_send_ipi_self':
   arch/x86/hyperv/hv_apic.c:189:12: error: invalid use of undefined type 
'struct apic'
      orig_apic.send_IPI_self(vector);
               ^
   arch/x86/hyperv/hv_apic.c: In function 'hv_apic_init':
>> arch/x86/hyperv/hv_apic.c:199:16: error: 'apic' undeclared (first use in 
>> this function)
      orig_apic = *apic;
                   ^~~~
   arch/x86/hyperv/hv_apic.c:199:16: note: each undeclared identifier is 
reported only once for each function it appears in
>> arch/x86/hyperv/hv_apic.c:199:13: error: 'orig_apic' has an incomplete type 
>> 'struct apic'
      orig_apic = *apic;
                ^
   arch/x86/hyperv/hv_apic.c:211:3: error: implicit declaration of function 
'apic_set_eoi_write'; did you mean 'hv_apic_eoi_write'? 
[-Werror=implicit-function-declaration]
      apic_set_eoi_write(hv_apic_eoi_write);
      ^~~~~~~~~~~~~~~~~~
      hv_apic_eoi_write
   arch/x86/hyperv/hv_apic.c: At top level:
>> arch/x86/hyperv/hv_apic.c:35:20: error: storage size of 'orig_apic' isn't 
>> known
    static struct apic orig_apic;
                       ^~~~~~~~~
   cc1: some warnings being treated as errors

vim +153 arch/x86/hyperv/hv_apic.c

    34  
  > 35  static struct apic orig_apic;
    36  
    37  static u64 hv_apic_icr_read(void)
    38  {
    39          u64 reg_val;
    40  
    41          rdmsrl(HV_X64_MSR_ICR, reg_val);
    42          return reg_val;
    43  }
    44  
    45  static void hv_apic_icr_write(u32 low, u32 id)
    46  {
    47          u64 reg_val;
    48  
    49          reg_val = SET_APIC_DEST_FIELD(id);
    50          reg_val = reg_val << 32;
    51          reg_val |= low;
    52  
    53          wrmsrl(HV_X64_MSR_ICR, reg_val);
    54  }
    55  
    56  static u32 hv_apic_read(u32 reg)
    57  {
    58          u32 reg_val, hi;
    59  
    60          switch (reg) {
    61          case APIC_EOI:
    62                  rdmsr(HV_X64_MSR_EOI, reg_val, hi);
    63                  return reg_val;
    64          case APIC_TASKPRI:
    65                  rdmsr(HV_X64_MSR_TPR, reg_val, hi);
    66                  return reg_val;
    67  
    68          default:
    69                  return native_apic_mem_read(reg);
    70          }
    71  }
    72  
    73  static void hv_apic_write(u32 reg, u32 val)
    74  {
    75          switch (reg) {
    76          case APIC_EOI:
    77                  wrmsr(HV_X64_MSR_EOI, val, 0);
    78                  break;
    79          case APIC_TASKPRI:
    80                  wrmsr(HV_X64_MSR_TPR, val, 0);
    81                  break;
    82          default:
  > 83                  native_apic_mem_write(reg, val);
    84          }
    85  }
    86  
    87  static void hv_apic_eoi_write(u32 reg, u32 val)
    88  {
    89          wrmsr(HV_X64_MSR_EOI, val, 0);
    90  }
    91  
    92  /*
    93   * IPI implementation on Hyper-V.
    94   */
    95  static bool __send_ipi_mask(const struct cpumask *mask, int vector)
    96  {
    97          int cur_cpu, vcpu;
    98          struct ipi_arg_non_ex **arg;
    99          struct ipi_arg_non_ex *ipi_arg;
   100          int ret = 1;
   101          unsigned long flags;
   102  
   103          if (cpumask_empty(mask))
   104                  return true;
   105  
   106          if (!hv_hypercall_pg)
   107                  return false;
   108  
   109          if ((vector < HV_IPI_LOW_VECTOR) || (vector > 
HV_IPI_HIGH_VECTOR))
   110                  return false;
   111  
   112          local_irq_save(flags);
   113          arg = (struct ipi_arg_non_ex 
**)this_cpu_ptr(hyperv_pcpu_input_arg);
   114  
   115          ipi_arg = *arg;
   116          if (unlikely(!ipi_arg))
   117                  goto ipi_mask_done;
   118  
   119          ipi_arg->vector = vector;
   120          ipi_arg->reserved = 0;
   121          ipi_arg->cpu_mask = 0;
   122  
   123          for_each_cpu(cur_cpu, mask) {
   124                  vcpu = hv_cpu_number_to_vp_number(cur_cpu);
   125                  /*
   126                   * This particular version of the IPI hypercall can
   127                   * only target upto 64 CPUs.
   128                   */
   129                  if (vcpu >= 64)
   130                          goto ipi_mask_done;
   131  
   132                  __set_bit(vcpu, (unsigned long *)&ipi_arg->cpu_mask);
   133          }
   134  
   135          ret = hv_do_hypercall(HVCALL_SEND_IPI, ipi_arg, NULL);
   136  
   137  ipi_mask_done:
   138          local_irq_restore(flags);
   139          return ((ret == 0) ? true : false);
   140  }
   141  
   142  static bool __send_ipi_one(int cpu, int vector)
   143  {
   144          struct cpumask mask = CPU_MASK_NONE;
   145  
   146          cpumask_set_cpu(cpu, &mask);
   147          return __send_ipi_mask(&mask, vector);
   148  }
   149  
   150  static void hv_send_ipi(int cpu, int vector)
   151  {
   152          if (!__send_ipi_one(cpu, vector))
 > 153                  orig_apic.send_IPI(cpu, vector);
   154  }
   155  
   156  static void hv_send_ipi_mask(const struct cpumask *mask, int vector)
   157  {
   158          if (!__send_ipi_mask(mask, vector))
   159                  orig_apic.send_IPI_mask(mask, vector);
   160  }
   161  
   162  static void hv_send_ipi_mask_allbutself(const struct cpumask *mask, int 
vector)
   163  {
   164          unsigned int this_cpu = smp_processor_id();
   165          struct cpumask new_mask;
   166          const struct cpumask *local_mask;
   167  
   168          cpumask_copy(&new_mask, mask);
   169          cpumask_clear_cpu(this_cpu, &new_mask);
   170          local_mask = &new_mask;
   171          if (!__send_ipi_mask(local_mask, vector))
   172                  orig_apic.send_IPI_mask_allbutself(mask, vector);
   173  }
   174  
   175  static void hv_send_ipi_allbutself(int vector)
   176  {
   177          hv_send_ipi_mask_allbutself(cpu_online_mask, vector);
   178  }
   179  
   180  static void hv_send_ipi_all(int vector)
   181  {
   182          if (!__send_ipi_mask(cpu_online_mask, vector))
 > 183                  orig_apic.send_IPI_all(vector);
   184  }
   185  
   186  static void hv_send_ipi_self(int vector)
   187  {
   188          if (!__send_ipi_one(smp_processor_id(), vector))
 > 189                  orig_apic.send_IPI_self(vector);
   190  }
   191  
   192  void __init hv_apic_init(void)
   193  {
   194          if (ms_hyperv.hints & HV_X64_CLUSTER_IPI_RECOMMENDED) {
   195                  pr_info("Hyper-V: Using IPI hypercalls\n");
   196                  /*
   197                   * Set the IPI entry points.
   198                   */
 > 199                  orig_apic = *apic;
   200  
   201                  apic->send_IPI = hv_send_ipi;
   202                  apic->send_IPI_mask = hv_send_ipi_mask;
   203                  apic->send_IPI_mask_allbutself = 
hv_send_ipi_mask_allbutself;
   204                  apic->send_IPI_allbutself = hv_send_ipi_allbutself;
   205                  apic->send_IPI_all = hv_send_ipi_all;
   206                  apic->send_IPI_self = hv_send_ipi_self;
   207          }
   208  
   209          if (ms_hyperv.hints & HV_X64_APIC_ACCESS_RECOMMENDED) {
   210                  pr_info("Hyper-V: Using MSR based APIC access\n");
   211                  apic_set_eoi_write(hv_apic_eoi_write);
   212                  apic->read      = hv_apic_read;
   213                  apic->write     = hv_apic_write;
   214                  apic->icr_write = hv_apic_icr_write;
   215                  apic->icr_read  = hv_apic_icr_read;
   216          }
   217  }
   218  

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

Attachment: .config.gz
Description: application/gzip

_______________________________________________
devel mailing list
de...@linuxdriverproject.org
http://driverdev.linuxdriverproject.org/mailman/listinfo/driverdev-devel

Reply via email to