void *payload, size_t payload_size)
 {
        struct hv_input_post_message *aligned_msg;
-       struct hv_per_cpu_context *hv_cpu;
+       unsigned long flags;
        u64 status;
 
        if (payload_size > HV_MESSAGE_PAYLOAD_BYTE_COUNT)
                return -EMSGSIZE;
 
-       hv_cpu = get_cpu_ptr(hv_context.cpu_context);
-       aligned_msg = hv_cpu->post_msg_page;
+       local_irq_save(flags);
+
+       aligned_msg = *this_cpu_ptr(hyperv_pcpu_input_arg);
        aligned_msg->connectionid = connection_id;
        aligned_msg->reserved = 0;
        aligned_msg->message_type = message_type;
                status = hv_do_hypercall(HVCALL_POST_MESSAGE,
                                aligned_msg, NULL);
 
-       /* Preemption must remain disabled until after the hypercall
-        * so some other thread can't get scheduled onto this cpu and
-        * corrupt the per-cpu post_msg_page
-        */
-       put_cpu_ptr(hv_cpu);
+       local_irq_restore(flags);
 
        return hv_result(status);
 }
                                goto err;
                        }
                }
-
-               hv_cpu->post_msg_page = (void *)get_zeroed_page(GFP_ATOMIC);
-               if (hv_cpu->post_msg_page == NULL) {
-                       pr_err("Unable to allocate post msg page\n");
-                       goto err;
-               }
        }
 
        return 0;
 
                free_page((unsigned long)hv_cpu->synic_event_page);
                free_page((unsigned long)hv_cpu->synic_message_page);
-               free_page((unsigned long)hv_cpu->post_msg_page);
        }
 
        kfree(hv_context.hv_numa_map);
 
 struct hv_per_cpu_context {
        void *synic_message_page;
        void *synic_event_page;
-       /*
-        * buffer to post messages to the host.
-        */
-       void *post_msg_page;
 
        /*
         * Starting with win8, we can take channel interrupts on any CPU;