1 files changed, 116 insertions, 23 deletions

diff --git a/drivers/infiniband/hw/qib/qib_init.c b/drivers/infiniband/hw/qib/qib_init.c
index 173f805790da..fdae42973056 100644
--- a/drivers/infiniband/hw/qib/qib_init.c
+++ b/drivers/infiniband/hw/qib/qib_init.c
@@ -39,10 +39,17 @@
 #include <linux/idr.h>
 #include <linux/module.h>
 #include <linux/printk.h>
+#ifdef CONFIG_INFINIBAND_QIB_DCA
+#include <linux/dca.h>
+#endif
 
 #include "qib.h"
 #include "qib_common.h"
 #include "qib_mad.h"
+#ifdef CONFIG_DEBUG_FS
+#include "qib_debugfs.h"
+#include "qib_verbs.h"
+#endif
 
 #undef pr_fmt
 #define pr_fmt(fmt) QIB_DRV_NAME ": " fmt
@@ -64,6 +71,11 @@ ushort qib_cfgctxts;
 module_param_named(cfgctxts, qib_cfgctxts, ushort, S_IRUGO);
 MODULE_PARM_DESC(cfgctxts, "Set max number of contexts to use");
 
+unsigned qib_numa_aware;
+module_param_named(numa_aware, qib_numa_aware, uint, S_IRUGO);
+MODULE_PARM_DESC(numa_aware,
+        "0 -> PSM allocation close to HCA, 1 -> PSM allocation local to process");
+
 /*
  * If set, do not write to any regs if avoidable, hack to allow
  * check for deranged default register values.
@@ -89,8 +101,6 @@ unsigned qib_wc_pat = 1; /* default (1) is to use PAT, not MTRR */
 module_param_named(wc_pat, qib_wc_pat, uint, S_IRUGO);
 MODULE_PARM_DESC(wc_pat, "enable write-combining via PAT mechanism");
 
-struct workqueue_struct *qib_cq_wq;
-
 static void verify_interrupt(unsigned long);
 
 static struct idr qib_unit_table;
@@ -121,6 +131,11 @@ int qib_create_ctxts(struct qib_devdata *dd)
 {
         unsigned i;
         int ret;
+        int local_node_id = pcibus_to_node(dd->pcidev->bus);
+
+        if (local_node_id < 0)
+                local_node_id = numa_node_id();
+        dd->assigned_node_id = local_node_id;
 
         /*
          * Allocate full ctxtcnt array, rather than just cfgctxts, because
@@ -143,7 +158,8 @@ int qib_create_ctxts(struct qib_devdata *dd)
                         continue;
 
                 ppd = dd->pport + (i % dd->num_pports);
-                rcd = qib_create_ctxtdata(ppd, i);
+
+                rcd = qib_create_ctxtdata(ppd, i, dd->assigned_node_id);
                 if (!rcd) {
                         qib_dev_err(dd,
                                 "Unable to allocate ctxtdata for Kernel ctxt, failing\n");
@@ -161,20 +177,33 @@ done:
 /*
  * Common code for user and kernel context setup.
  */
-struct qib_ctxtdata *qib_create_ctxtdata(struct qib_pportdata *ppd, u32 ctxt)
+struct qib_ctxtdata *qib_create_ctxtdata(struct qib_pportdata *ppd, u32 ctxt,
+        int node_id)
 {
         struct qib_devdata *dd = ppd->dd;
         struct qib_ctxtdata *rcd;
 
-        rcd = kzalloc(sizeof(*rcd), GFP_KERNEL);
+        rcd = kzalloc_node(sizeof(*rcd), GFP_KERNEL, node_id);
         if (rcd) {
                 INIT_LIST_HEAD(&rcd->qp_wait_list);
+                rcd->node_id = node_id;
                 rcd->ppd = ppd;
                 rcd->dd = dd;
                 rcd->cnt = 1;
                 rcd->ctxt = ctxt;
                 dd->rcd[ctxt] = rcd;
-
+#ifdef CONFIG_DEBUG_FS
+                if (ctxt < dd->first_user_ctxt) { /* N/A for PSM contexts */
+                        rcd->opstats = kzalloc_node(sizeof(*rcd->opstats),
+                                GFP_KERNEL, node_id);
+                        if (!rcd->opstats) {
+                                kfree(rcd);
+                                qib_dev_err(dd,
+                                        "Unable to allocate per ctxt stats buffer\n");
+                                return NULL;
+                        }
+                }
+#endif
                 dd->f_init_ctxt(rcd);
 
                 /*
@@ -429,6 +458,7 @@ static int loadtime_init(struct qib_devdata *dd)
         dd->intrchk_timer.function = verify_interrupt;
         dd->intrchk_timer.data = (unsigned long) dd;
 
+        ret = qib_cq_init(dd);
 done:
         return ret;
 }
@@ -944,6 +974,10 @@ void qib_free_ctxtdata(struct qib_devdata *dd, struct qib_ctxtdata *rcd)
         vfree(rcd->subctxt_uregbase);
         vfree(rcd->subctxt_rcvegrbuf);
         vfree(rcd->subctxt_rcvhdr_base);
+#ifdef CONFIG_DEBUG_FS
+        kfree(rcd->opstats);
+        rcd->opstats = NULL;
+#endif
         kfree(rcd);
 }
 
@@ -1033,7 +1067,6 @@ done:
         dd->f_set_armlaunch(dd, 1);
 }
 
-
 void qib_free_devdata(struct qib_devdata *dd)
 {
         unsigned long flags;
@@ -1043,6 +1076,9 @@ void qib_free_devdata(struct qib_devdata *dd)
         list_del(&dd->list);
         spin_unlock_irqrestore(&qib_devs_lock, flags);
 
+#ifdef CONFIG_DEBUG_FS
+        qib_dbg_ibdev_exit(&dd->verbs_dev);
+#endif
         ib_dealloc_device(&dd->verbs_dev.ibdev);
 }
 
@@ -1066,6 +1102,10 @@ struct qib_devdata *qib_alloc_devdata(struct pci_dev *pdev, size_t extra)
                 goto bail;
         }
 
+#ifdef CONFIG_DEBUG_FS
+        qib_dbg_ibdev_init(&dd->verbs_dev);
+#endif
+
         idr_preload(GFP_KERNEL);
         spin_lock_irqsave(&qib_devs_lock, flags);
 
@@ -1081,6 +1121,9 @@ struct qib_devdata *qib_alloc_devdata(struct pci_dev *pdev, size_t extra)
         if (ret < 0) {
                 qib_early_err(&pdev->dev,
                               "Could not allocate unit ID: error %d\n", -ret);
+#ifdef CONFIG_DEBUG_FS
+                qib_dbg_ibdev_exit(&dd->verbs_dev);
+#endif
                 ib_dealloc_device(&dd->verbs_dev.ibdev);
                 dd = ERR_PTR(ret);
                 goto bail;
@@ -1158,6 +1201,35 @@ struct pci_driver qib_driver = {
         .err_handler = &qib_pci_err_handler,
 };
 
+#ifdef CONFIG_INFINIBAND_QIB_DCA
+
+static int qib_notify_dca(struct notifier_block *, unsigned long, void *);
+static struct notifier_block dca_notifier = {
+        .notifier_call  = qib_notify_dca,
+        .next           = NULL,
+        .priority       = 0
+};
+
+static int qib_notify_dca_device(struct device *device, void *data)
+{
+        struct qib_devdata *dd = dev_get_drvdata(device);
+        unsigned long event = *(unsigned long *)data;
+
+        return dd->f_notify_dca(dd, event);
+}
+
+static int qib_notify_dca(struct notifier_block *nb, unsigned long event,
+                                          void *p)
+{
+        int rval;
+
+        rval = driver_for_each_device(&qib_driver.driver, NULL,
+                                      &event, qib_notify_dca_device);
+        return rval ? NOTIFY_BAD : NOTIFY_DONE;
+}
+
+#endif
+
 /*
  * Do all the generic driver unit- and chip-independent memory
  * allocation and initialization.
@@ -1170,22 +1242,22 @@ static int __init qlogic_ib_init(void)
         if (ret)
                 goto bail;
 
-        qib_cq_wq = create_singlethread_workqueue("qib_cq");
-        if (!qib_cq_wq) {
-                ret = -ENOMEM;
-                goto bail_dev;
-        }
-
         /*
          * These must be called before the driver is registered with
          * the PCI subsystem.
          */
         idr_init(&qib_unit_table);
 
+#ifdef CONFIG_INFINIBAND_QIB_DCA
+        dca_register_notify(&dca_notifier);
+#endif
+#ifdef CONFIG_DEBUG_FS
+        qib_dbg_init();
+#endif
         ret = pci_register_driver(&qib_driver);
         if (ret < 0) {
                 pr_err("Unable to register driver: error %d\n", -ret);
-                goto bail_unit;
+                goto bail_dev;
         }
 
         /* not fatal if it doesn't work */
@@ -1193,10 +1265,14 @@ static int __init qlogic_ib_init(void)
                 pr_err("Unable to register ipathfs\n");
         goto bail; /* all OK */
 
-bail_unit:
-        idr_destroy(&qib_unit_table);
-        destroy_workqueue(qib_cq_wq);
 bail_dev:
+#ifdef CONFIG_INFINIBAND_QIB_DCA
+        dca_unregister_notify(&dca_notifier);
+#endif
+#ifdef CONFIG_DEBUG_FS
+        qib_dbg_exit();
+#endif
+        idr_destroy(&qib_unit_table);
         qib_dev_cleanup();
 bail:
         return ret;
@@ -1217,9 +1293,13 @@ static void __exit qlogic_ib_cleanup(void)
                         "Unable to cleanup counter filesystem: error %d\n",
                         -ret);
 
+#ifdef CONFIG_INFINIBAND_QIB_DCA
+        dca_unregister_notify(&dca_notifier);
+#endif
         pci_unregister_driver(&qib_driver);
-
-        destroy_workqueue(qib_cq_wq);
+#ifdef CONFIG_DEBUG_FS
+        qib_dbg_exit();
+#endif
 
         qib_cpulist_count = 0;
         kfree(qib_cpulist);
@@ -1311,6 +1391,7 @@ static void cleanup_device_data(struct qib_devdata *dd)
         }
         kfree(tmp);
         kfree(dd->boardname);
+        qib_cq_exit(dd);
 }
 
 /*
@@ -1483,6 +1564,7 @@ static void qib_remove_one(struct pci_dev *pdev)
 int qib_create_rcvhdrq(struct qib_devdata *dd, struct qib_ctxtdata *rcd)
 {
         unsigned amt;
+        int old_node_id;
 
         if (!rcd->rcvhdrq) {
                 dma_addr_t phys_hdrqtail;
@@ -1492,9 +1574,13 @@ int qib_create_rcvhdrq(struct qib_devdata *dd, struct qib_ctxtdata *rcd)
                             sizeof(u32), PAGE_SIZE);
                 gfp_flags = (rcd->ctxt >= dd->first_user_ctxt) ?
                         GFP_USER : GFP_KERNEL;
+
+                old_node_id = dev_to_node(&dd->pcidev->dev);
+                set_dev_node(&dd->pcidev->dev, rcd->node_id);
                 rcd->rcvhdrq = dma_alloc_coherent(
                         &dd->pcidev->dev, amt, &rcd->rcvhdrq_phys,
                         gfp_flags | __GFP_COMP);
+                set_dev_node(&dd->pcidev->dev, old_node_id);
 
                 if (!rcd->rcvhdrq) {
                         qib_dev_err(dd,
@@ -1510,9 +1596,11 @@ int qib_create_rcvhdrq(struct qib_devdata *dd, struct qib_ctxtdata *rcd)
                 }
 
                 if (!(dd->flags & QIB_NODMA_RTAIL)) {
+                        set_dev_node(&dd->pcidev->dev, rcd->node_id);
                         rcd->rcvhdrtail_kvaddr = dma_alloc_coherent(
                                 &dd->pcidev->dev, PAGE_SIZE, &phys_hdrqtail,
                                 gfp_flags);
+                        set_dev_node(&dd->pcidev->dev, old_node_id);
                         if (!rcd->rcvhdrtail_kvaddr)
                                 goto bail_free;
                         rcd->rcvhdrqtailaddr_phys = phys_hdrqtail;
@@ -1556,6 +1644,7 @@ int qib_setup_eagerbufs(struct qib_ctxtdata *rcd)
         unsigned e, egrcnt, egrperchunk, chunk, egrsize, egroff;
         size_t size;
         gfp_t gfp_flags;
+        int old_node_id;
 
         /*
          * GFP_USER, but without GFP_FS, so buffer cache can be
@@ -1574,25 +1663,29 @@ int qib_setup_eagerbufs(struct qib_ctxtdata *rcd)
         size = rcd->rcvegrbuf_size;
         if (!rcd->rcvegrbuf) {
                 rcd->rcvegrbuf =
-                        kzalloc(chunk * sizeof(rcd->rcvegrbuf[0]),
-                                GFP_KERNEL);
+                        kzalloc_node(chunk * sizeof(rcd->rcvegrbuf[0]),
+                                GFP_KERNEL, rcd->node_id);
                 if (!rcd->rcvegrbuf)
                         goto bail;
         }
         if (!rcd->rcvegrbuf_phys) {
                 rcd->rcvegrbuf_phys =
-                        kmalloc(chunk * sizeof(rcd->rcvegrbuf_phys[0]),
-                                GFP_KERNEL);
+                        kmalloc_node(chunk * sizeof(rcd->rcvegrbuf_phys[0]),
+                                GFP_KERNEL, rcd->node_id);
                 if (!rcd->rcvegrbuf_phys)
                         goto bail_rcvegrbuf;
         }
         for (e = 0; e < rcd->rcvegrbuf_chunks; e++) {
                 if (rcd->rcvegrbuf[e])
                         continue;
+
+                old_node_id = dev_to_node(&dd->pcidev->dev);
+                set_dev_node(&dd->pcidev->dev, rcd->node_id);
                 rcd->rcvegrbuf[e] =
                         dma_alloc_coherent(&dd->pcidev->dev, size,
                                            &rcd->rcvegrbuf_phys[e],
                                            gfp_flags);
+                set_dev_node(&dd->pcidev->dev, old_node_id);
                 if (!rcd->rcvegrbuf[e])
                         goto bail_rcvegrbuf_phys;
         }