{ "halt_exits", &kvm_stat.halt_exits },
        { "request_irq", &kvm_stat.request_irq_exits },
        { "irq_exits", &kvm_stat.irq_exits },
-       { 0, 0 }
+       { NULL, NULL }
 };
 
 static struct dentry *debugfs_dir;
        mutex_lock(&vcpu->mutex);
        if (unlikely(!vcpu->vmcs)) {
                mutex_unlock(&vcpu->mutex);
-               return 0;
+               return NULL;
        }
        return kvm_arch_ops->vcpu_load(vcpu);
 }
        if (!dont || free->dirty_bitmap != dont->dirty_bitmap)
                vfree(free->dirty_bitmap);
 
-       free->phys_mem = 0;
+       free->phys_mem = NULL;
        free->npages = 0;
-       free->dirty_bitmap = 0;
+       free->dirty_bitmap = NULL;
 }
 
 static void kvm_free_physmem(struct kvm *kvm)
        int i;
 
        for (i = 0; i < kvm->nmemslots; ++i)
-               kvm_free_physmem_slot(&kvm->memslots[i], 0);
+               kvm_free_physmem_slot(&kvm->memslots[i], NULL);
 }
 
 static void kvm_free_vcpu(struct kvm_vcpu *vcpu)
 
        /* Deallocate if slot is being removed */
        if (!npages)
-               new.phys_mem = 0;
+               new.phys_mem = NULL;
 
        /* Free page dirty bitmap if unneeded */
        if (!(new.flags & KVM_MEM_LOG_DIRTY_PAGES))
-               new.dirty_bitmap = 0;
+               new.dirty_bitmap = NULL;
 
        r = -ENOMEM;
 
                    && gfn < memslot->base_gfn + memslot->npages)
                        return memslot;
        }
-       return 0;
+       return NULL;
 }
 EXPORT_SYMBOL_GPL(gfn_to_memslot);
 
 void mark_page_dirty(struct kvm *kvm, gfn_t gfn)
 {
        int i;
-       struct kvm_memory_slot *memslot = 0;
+       struct kvm_memory_slot *memslot = NULL;
        unsigned long rel_gfn;
 
        for (i = 0; i < kvm->nmemslots; ++i) {
                 * in vmx root mode.
                 */
                printk(KERN_INFO "kvm: exiting hardware virtualization\n");
-               on_each_cpu(kvm_arch_ops->hardware_disable, 0, 0, 1);
+               on_each_cpu(kvm_arch_ops->hardware_disable, NULL, 0, 1);
        }
        return NOTIFY_OK;
 }
 {
        struct kvm_stats_debugfs_item *p;
 
-       debugfs_dir = debugfs_create_dir("kvm", 0);
+       debugfs_dir = debugfs_create_dir("kvm", NULL);
        for (p = debugfs_entries; p->name; ++p)
                p->dentry = debugfs_create_u32(p->name, 0444, debugfs_dir,
                                               p->data);
        if (r < 0)
            return r;
 
-       on_each_cpu(kvm_arch_ops->hardware_enable, 0, 0, 1);
+       on_each_cpu(kvm_arch_ops->hardware_enable, NULL, 0, 1);
        register_reboot_notifier(&kvm_reboot_notifier);
 
        kvm_chardev_ops.owner = module;
 
 out_free:
        unregister_reboot_notifier(&kvm_reboot_notifier);
-       on_each_cpu(kvm_arch_ops->hardware_disable, 0, 0, 1);
+       on_each_cpu(kvm_arch_ops->hardware_disable, NULL, 0, 1);
        kvm_arch_ops->hardware_unsetup();
        return r;
 }
        misc_deregister(&kvm_dev);
 
        unregister_reboot_notifier(&kvm_reboot_notifier);
-       on_each_cpu(kvm_arch_ops->hardware_disable, 0, 0, 1);
+       on_each_cpu(kvm_arch_ops->hardware_disable, NULL, 0, 1);
        kvm_arch_ops->hardware_unsetup();
        kvm_arch_ops = NULL;
 }
 
                wrmsrl(MSR_VM_HSAVE_PA, 0);
                rdmsrl(MSR_EFER, efer);
                wrmsrl(MSR_EFER, efer & ~MSR_EFER_SVME_MASK);
-               per_cpu(svm_data, raw_smp_processor_id()) = 0;
+               per_cpu(svm_data, raw_smp_processor_id()) = NULL;
                __free_page(svm_data->save_area);
                kfree(svm_data);
        }
        case VCPU_SREG_LDTR: return &save->ldtr;
        }
        BUG();
-       return 0;
+       return NULL;
 }
 
 static u64 svm_get_segment_base(struct kvm_vcpu *vcpu, int seg)
                return 0;
 
        *addr_override = 0;
-       *seg = 0;
+       *seg = NULL;
        for (i = 0; i < ins_length; i++)
                switch (inst[i]) {
                case 0xf0:
 
 static int emulate_on_interception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
-       if (emulate_instruction(vcpu, 0, 0, 0) != EMULATE_DONE)
+       if (emulate_instruction(vcpu, NULL, 0, 0) != EMULATE_DONE)
                printk(KERN_ERR "%s: failed\n", __FUNCTION__);
        return 1;
 }