macro for fixed-size operator new and delete

1c77c3b0 · Nickolai Zeldovich · 958c2e7f · 1c77c3b0 · 1c77c3b0 · 1c77c3b0
--- a/include/buf.hh
+++ b/include/buf.hh
 #include "gc.hh"
 #include "atomic.hh"
+#include "cpputil.hh"
 using std::atomic;
@@ -17,15 +18,7 @@ struct buf : public rcu_freed {
  buf() : rcu_freed("buf") {}
  virtual void do_gc() { delete this; }
+  NEW_DELETE_OPS(buf)
-  static void* operator new(unsigned long nbytes) {
-    assert(nbytes == sizeof(buf));
-    return kmalloc(sizeof(buf));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(buf));
-  }
 };
 #define B_BUSY  0x1  // buffer is locked by some process
 #define B_VALID 0x2  // buffer has been read from disk

--- a/include/cpputil.hh
+++ b/include/cpputil.hh
@@ -67,8 +67,20 @@ namespace std {
 }
 /* C++ runtime */
-void *operator new(unsigned long nbytes);
+// void *operator new(unsigned long nbytes);
-void *operator new(unsigned long nbytes, void *buf);
+// void *operator new(unsigned long nbytes, void *buf);
-void operator delete(void *p);
+void *operator new[](unsigned long nbytes);
+// void operator delete(void *p);
+void operator delete[](void *p);
 extern "C" void __cxa_pure_virtual(void);
+#define NEW_DELETE_OPS(classname)                           \
+  static void* operator new(unsigned long nbytes) {         \
+    assert(nbytes == sizeof(classname));                    \
+    return kmalloc(sizeof(classname));                      \
+  }                                                         \
+                                                            \
+  static void operator delete(void *p) {                    \
+    return kmfree(p, sizeof(classname));                    \
+  }
--- a/include/cpu.hh
+++ b/include/cpu.hh
+#pragma once
 #include "mmu.h"
 #include "atomic.hh"

--- a/include/crange.hh
+++ b/include/crange.hh
@@ -110,14 +110,7 @@ struct range_head : public range {
  range_head(crange *cr, u64 k, u64 sz, int nlevel)
    : range(cr, k, sz, nlevel) {}
-  static void* operator new(unsigned long nbytes) {
+  NEW_DELETE_OPS(range_head)
-    assert(nbytes == sizeof(range_head));
-    return kmalloc(sizeof(range_head));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(range_head));
-  }
  virtual void do_gc() {
    delete this;
@@ -165,15 +158,7 @@ struct crange {
  range_iterator begin() const { return range_iterator(crange_head->next[0].ptr()); };
  range_iterator end() const { return range_iterator(0); };
+  NEW_DELETE_OPS(crange)
-  static void* operator new(unsigned long nbytes) {
-    assert(nbytes == sizeof(crange));
-    return kmalloc(sizeof(crange));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(crange));
-  }
 };
 static inline range_iterator

--- a/include/crange_arch.hh
+++ b/include/crange_arch.hh
@@ -6,3 +6,4 @@
 #include "atomic.hh"
 #include "proc.hh"
 #include "cpu.hh"
+#include "cpputil.hh"
--- a/include/file.hh
+++ b/include/file.hh
@@ -42,15 +42,7 @@ struct inode : public rcu_freed {
  inode();
  ~inode();
  virtual void do_gc() { delete this; }
+  NEW_DELETE_OPS(inode)
-  static void* operator new(unsigned long nbytes) {
-    assert(nbytes == sizeof(inode));
-    return kmalloc(sizeof(inode));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(inode));
-  }
 };
 #define I_BUSYR 0x1

--- a/include/ns.hh
+++ b/include/ns.hh
@@ -24,14 +24,7 @@ class xelem : public rcu_freed {
    delete this;
  }
-  static void* operator new(unsigned long nbytes) {
+  NEW_DELETE_OPS(xelem)
-    assert(nbytes == sizeof(xelem));
-    return kmalloc(sizeof(xelem));
-  }
-  static void operator delete(void *p) {
-    kmfree(p, sizeof(xelem));
-  }
 };
 template<class K, class V>
@@ -227,14 +220,7 @@ class xns : public rcu_freed {
    return iterator();
  }
-  static void* operator new(unsigned long nbytes) {
+  NEW_DELETE_OPS(xns)
-    assert(nbytes == sizeof(xns));
-    return kmalloc(sizeof(xns));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(xns));
-  }
 };
 template<class K, class V, u64 (*HF)(const K&)>

--- a/include/proc.hh
+++ b/include/proc.hh
+#pragma once
 #include "spinlock.h"
 #include "atomic.hh"

--- a/include/vm.hh
+++ b/include/vm.hh
 #include "gc.hh"
 #include "atomic.hh"
+#include "crange_arch.hh"
 #include "crange.hh"
 #include "cpputil.hh"
 #include "hwvm.hh"
@@ -26,15 +27,7 @@ struct vmnode {
  vmnode* copy();
  int demand_load();
+  NEW_DELETE_OPS(vmnode)
-  static void* operator new(unsigned long nbytes) {
-    assert(nbytes == sizeof(vmnode));
-    return kmalloc(sizeof(vmnode));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(vmnode));
-  }
 };
 // A mapping of a chunk of an address space to
@@ -51,15 +44,7 @@ struct vma : public range {
  ~vma();
  virtual void do_gc() { delete this; }
+  NEW_DELETE_OPS(vma)
-  static void* operator new(unsigned long nbytes) {
-    assert(nbytes == sizeof(vma));
-    return kmalloc(sizeof(vma));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(vma));
-  }
 };
 // An address space: a set of vmas plus h/w page table.
@@ -83,15 +68,7 @@ struct vmap {
  int pagefault(uptr va, u32 err);
  int copyout(uptr va, void *p, u64 len);
+  NEW_DELETE_OPS(vmap)
-  static void* operator new(unsigned long nbytes) {
-    assert(nbytes == sizeof(vmap));
-    return kmalloc(sizeof(vmap));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(vmap));
-  }
 private:
  int pagefault_wcow(vma *m);

--- a/kernel/fs.cc
+++ b/kernel/fs.cc
@@ -485,14 +485,7 @@ class diskblock : public rcu_freed {
    delete this;
  }
-  static void* operator new(unsigned long nbytes) {
+  NEW_DELETE_OPS(diskblock)
-    assert(nbytes == sizeof(diskblock));
-    return kmalloc(sizeof(diskblock));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(diskblock));
-  }
 };
 static void

--- a/kernel/proc.cc
+++ b/kernel/proc.cc
@@ -188,14 +188,7 @@ class delayed_proc_free : public rcu_freed {
    delete this;
  }
-  static void* operator new(unsigned long nbytes) {
+  NEW_DELETE_OPS(delayed_proc_free)
-    assert(nbytes == sizeof(delayed_proc_free));
-    return kmalloc(sizeof(delayed_proc_free));
-  }
-  static void operator delete(void *p) {
-    return kmfree(p, sizeof(delayed_proc_free));
-  }
 };
 static void