drivers/staging/lustre/lnet/libcfs/linux/linux-cpu.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * GPL HEADER END
  17  */
  18 /*
  19  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  20  *
  21  * Copyright (c) 2012, 2015 Intel Corporation.
  22  */
  23 /*
  24  * This file is part of Lustre, http://www.lustre.org/
  25  * Lustre is a trademark of Sun Microsystems, Inc.
  26  *
  27  * Author: liang@whamcloud.com
  28  */
  29
  30 #define DEBUG_SUBSYSTEM S_LNET
  31
  32 #include <linux/cpu.h>
  33 #include <linux/sched.h>
  34 #include "../../../include/linux/libcfs/libcfs.h"
  35
  36 #ifdef CONFIG_SMP
  37
  38 /**
  39  * modparam for setting number of partitions
  40  *
  41  *  0 : estimate best value based on cores or NUMA nodes
  42  *  1 : disable multiple partitions
  43  * >1 : specify number of partitions
  44  */
  45 static int      cpu_npartitions;
  46 module_param(cpu_npartitions, int, 0444);
  47 MODULE_PARM_DESC(cpu_npartitions, "# of CPU partitions");
  48
  49 /**
  50  * modparam for setting CPU partitions patterns:
  51  *
  52  * i.e: "0[0,1,2,3] 1[4,5,6,7]", number before bracket is CPU partition ID,
  53  *      number in bracket is processor ID (core or HT)
  54  *
  55  * i.e: "N 0[0,1] 1[2,3]" the first character 'N' means numbers in bracket
  56  *       are NUMA node ID, number before bracket is CPU partition ID.
  57  *
  58  * NB: If user specified cpu_pattern, cpu_npartitions will be ignored
  59  */
  60 static char     *cpu_pattern = "";
  61 module_param(cpu_pattern, charp, 0444);
  62 MODULE_PARM_DESC(cpu_pattern, "CPU partitions pattern");
  63
  64 struct cfs_cpt_data {
  65         /* serialize hotplug etc */
  66         spinlock_t              cpt_lock;
  67         /* reserved for hotplug */
  68         unsigned long           cpt_version;
  69         /* mutex to protect cpt_cpumask */
  70         struct mutex            cpt_mutex;
  71         /* scratch buffer for set/unset_node */
  72         cpumask_t               *cpt_cpumask;
  73 };
  74
  75 static struct cfs_cpt_data      cpt_data;
  76
  77 void
  78 cfs_cpt_table_free(struct cfs_cpt_table *cptab)
  79 {
  80         int     i;
  81
  82         if (cptab->ctb_cpu2cpt) {
  83                 LIBCFS_FREE(cptab->ctb_cpu2cpt,
  84                             num_possible_cpus() *
  85                             sizeof(cptab->ctb_cpu2cpt[0]));
  86         }
  87
  88         for (i = 0; cptab->ctb_parts && i < cptab->ctb_nparts; i++) {
  89                 struct cfs_cpu_partition *part = &cptab->ctb_parts[i];
  90
  91                 if (part->cpt_nodemask) {
  92                         LIBCFS_FREE(part->cpt_nodemask,
  93                                     sizeof(*part->cpt_nodemask));
  94                 }
  95
  96                 if (part->cpt_cpumask)
  97                         LIBCFS_FREE(part->cpt_cpumask, cpumask_size());
  98         }
  99
 100         if (cptab->ctb_parts) {
 101                 LIBCFS_FREE(cptab->ctb_parts,
 102                             cptab->ctb_nparts * sizeof(cptab->ctb_parts[0]));
 103         }
 104
 105         if (cptab->ctb_nodemask)
 106                 LIBCFS_FREE(cptab->ctb_nodemask, sizeof(*cptab->ctb_nodemask));
 107         if (cptab->ctb_cpumask)
 108                 LIBCFS_FREE(cptab->ctb_cpumask, cpumask_size());
 109
 110         LIBCFS_FREE(cptab, sizeof(*cptab));
 111 }
 112 EXPORT_SYMBOL(cfs_cpt_table_free);
 113
 114 struct cfs_cpt_table *
 115 cfs_cpt_table_alloc(unsigned int ncpt)
 116 {
 117         struct cfs_cpt_table *cptab;
 118         int     i;
 119
 120         LIBCFS_ALLOC(cptab, sizeof(*cptab));
 121         if (!cptab)
 122                 return NULL;
 123
 124         cptab->ctb_nparts = ncpt;
 125
 126         LIBCFS_ALLOC(cptab->ctb_cpumask, cpumask_size());
 127         LIBCFS_ALLOC(cptab->ctb_nodemask, sizeof(*cptab->ctb_nodemask));
 128
 129         if (!cptab->ctb_cpumask || !cptab->ctb_nodemask)
 130                 goto failed;
 131
 132         LIBCFS_ALLOC(cptab->ctb_cpu2cpt,
 133                      num_possible_cpus() * sizeof(cptab->ctb_cpu2cpt[0]));
 134         if (!cptab->ctb_cpu2cpt)
 135                 goto failed;
 136
 137         memset(cptab->ctb_cpu2cpt, -1,
 138                num_possible_cpus() * sizeof(cptab->ctb_cpu2cpt[0]));
 139
 140         LIBCFS_ALLOC(cptab->ctb_parts, ncpt * sizeof(cptab->ctb_parts[0]));
 141         if (!cptab->ctb_parts)
 142                 goto failed;
 143
 144         for (i = 0; i < ncpt; i++) {
 145                 struct cfs_cpu_partition *part = &cptab->ctb_parts[i];
 146
 147                 LIBCFS_ALLOC(part->cpt_cpumask, cpumask_size());
 148                 LIBCFS_ALLOC(part->cpt_nodemask, sizeof(*part->cpt_nodemask));
 149                 if (!part->cpt_cpumask || !part->cpt_nodemask)
 150                         goto failed;
 151         }
 152
 153         spin_lock(&cpt_data.cpt_lock);
 154         /* Reserved for hotplug */
 155         cptab->ctb_version = cpt_data.cpt_version;
 156         spin_unlock(&cpt_data.cpt_lock);
 157
 158         return cptab;
 159
 160  failed:
 161         cfs_cpt_table_free(cptab);
 162         return NULL;
 163 }
 164 EXPORT_SYMBOL(cfs_cpt_table_alloc);
 165
 166 int
 167 cfs_cpt_table_print(struct cfs_cpt_table *cptab, char *buf, int len)
 168 {
 169         char    *tmp = buf;
 170         int     rc = 0;
 171         int     i;
 172         int     j;
 173
 174         for (i = 0; i < cptab->ctb_nparts; i++) {
 175                 if (len > 0) {
 176                         rc = snprintf(tmp, len, "%d\t: ", i);
 177                         len -= rc;
 178                 }
 179
 180                 if (len <= 0) {
 181                         rc = -EFBIG;
 182                         goto out;
 183                 }
 184
 185                 tmp += rc;
 186                 for_each_cpu(j, cptab->ctb_parts[i].cpt_cpumask) {
 187                         rc = snprintf(tmp, len, "%d ", j);
 188                         len -= rc;
 189                         if (len <= 0) {
 190                                 rc = -EFBIG;
 191                                 goto out;
 192                         }
 193                         tmp += rc;
 194                 }
 195
 196                 *tmp = '\n';
 197                 tmp++;
 198                 len--;
 199         }
 200
 201  out:
 202         if (rc < 0)
 203                 return rc;
 204
 205         return tmp - buf;
 206 }
 207 EXPORT_SYMBOL(cfs_cpt_table_print);
 208
 209 int
 210 cfs_cpt_number(struct cfs_cpt_table *cptab)
 211 {
 212         return cptab->ctb_nparts;
 213 }
 214 EXPORT_SYMBOL(cfs_cpt_number);
 215
 216 int
 217 cfs_cpt_weight(struct cfs_cpt_table *cptab, int cpt)
 218 {
 219         LASSERT(cpt == CFS_CPT_ANY || (cpt >= 0 && cpt < cptab->ctb_nparts));
 220
 221         return cpt == CFS_CPT_ANY ?
 222                cpumask_weight(cptab->ctb_cpumask) :
 223                cpumask_weight(cptab->ctb_parts[cpt].cpt_cpumask);
 224 }
 225 EXPORT_SYMBOL(cfs_cpt_weight);
 226
 227 int
 228 cfs_cpt_online(struct cfs_cpt_table *cptab, int cpt)
 229 {
 230         LASSERT(cpt == CFS_CPT_ANY || (cpt >= 0 && cpt < cptab->ctb_nparts));
 231
 232         return cpt == CFS_CPT_ANY ?
 233                cpumask_any_and(cptab->ctb_cpumask,
 234                                cpu_online_mask) < nr_cpu_ids :
 235                cpumask_any_and(cptab->ctb_parts[cpt].cpt_cpumask,
 236                                cpu_online_mask) < nr_cpu_ids;
 237 }
 238 EXPORT_SYMBOL(cfs_cpt_online);
 239
 240 cpumask_t *
 241 cfs_cpt_cpumask(struct cfs_cpt_table *cptab, int cpt)
 242 {
 243         LASSERT(cpt == CFS_CPT_ANY || (cpt >= 0 && cpt < cptab->ctb_nparts));
 244
 245         return cpt == CFS_CPT_ANY ?
 246                cptab->ctb_cpumask : cptab->ctb_parts[cpt].cpt_cpumask;
 247 }
 248 EXPORT_SYMBOL(cfs_cpt_cpumask);
 249
 250 nodemask_t *
 251 cfs_cpt_nodemask(struct cfs_cpt_table *cptab, int cpt)
 252 {
 253         LASSERT(cpt == CFS_CPT_ANY || (cpt >= 0 && cpt < cptab->ctb_nparts));
 254
 255         return cpt == CFS_CPT_ANY ?
 256                cptab->ctb_nodemask : cptab->ctb_parts[cpt].cpt_nodemask;
 257 }
 258 EXPORT_SYMBOL(cfs_cpt_nodemask);
 259
 260 int
 261 cfs_cpt_set_cpu(struct cfs_cpt_table *cptab, int cpt, int cpu)
 262 {
 263         int     node;
 264
 265         LASSERT(cpt >= 0 && cpt < cptab->ctb_nparts);
 266
 267         if (cpu < 0 || cpu >= nr_cpu_ids || !cpu_online(cpu)) {
 268                 CDEBUG(D_INFO, "CPU %d is invalid or it's offline\n", cpu);
 269                 return 0;
 270         }
 271
 272         if (cptab->ctb_cpu2cpt[cpu] != -1) {
 273                 CDEBUG(D_INFO, "CPU %d is already in partition %d\n",
 274                        cpu, cptab->ctb_cpu2cpt[cpu]);
 275                 return 0;
 276         }
 277
 278         cptab->ctb_cpu2cpt[cpu] = cpt;
 279
 280         LASSERT(!cpumask_test_cpu(cpu, cptab->ctb_cpumask));
 281         LASSERT(!cpumask_test_cpu(cpu, cptab->ctb_parts[cpt].cpt_cpumask));
 282
 283         cpumask_set_cpu(cpu, cptab->ctb_cpumask);
 284         cpumask_set_cpu(cpu, cptab->ctb_parts[cpt].cpt_cpumask);
 285
 286         node = cpu_to_node(cpu);
 287
 288         /* first CPU of @node in this CPT table */
 289         if (!node_isset(node, *cptab->ctb_nodemask))
 290                 node_set(node, *cptab->ctb_nodemask);
 291
 292         /* first CPU of @node in this partition */
 293         if (!node_isset(node, *cptab->ctb_parts[cpt].cpt_nodemask))
 294                 node_set(node, *cptab->ctb_parts[cpt].cpt_nodemask);
 295
 296         return 1;
 297 }
 298 EXPORT_SYMBOL(cfs_cpt_set_cpu);
 299
 300 void
 301 cfs_cpt_unset_cpu(struct cfs_cpt_table *cptab, int cpt, int cpu)
 302 {
 303         int     node;
 304         int     i;
 305
 306         LASSERT(cpt == CFS_CPT_ANY || (cpt >= 0 && cpt < cptab->ctb_nparts));
 307
 308         if (cpu < 0 || cpu >= nr_cpu_ids) {
 309                 CDEBUG(D_INFO, "Invalid CPU id %d\n", cpu);
 310                 return;
 311         }
 312
 313         if (cpt == CFS_CPT_ANY) {
 314                 /* caller doesn't know the partition ID */
 315                 cpt = cptab->ctb_cpu2cpt[cpu];
 316                 if (cpt < 0) { /* not set in this CPT-table */
 317                         CDEBUG(D_INFO, "Try to unset cpu %d which is not in CPT-table %p\n",
 318                                cpt, cptab);
 319                         return;
 320                 }
 321
 322         } else if (cpt != cptab->ctb_cpu2cpt[cpu]) {
 323                 CDEBUG(D_INFO,
 324                        "CPU %d is not in cpu-partition %d\n", cpu, cpt);
 325                 return;
 326         }
 327
 328         LASSERT(cpumask_test_cpu(cpu, cptab->ctb_parts[cpt].cpt_cpumask));
 329         LASSERT(cpumask_test_cpu(cpu, cptab->ctb_cpumask));
 330
 331         cpumask_clear_cpu(cpu, cptab->ctb_parts[cpt].cpt_cpumask);
 332         cpumask_clear_cpu(cpu, cptab->ctb_cpumask);
 333         cptab->ctb_cpu2cpt[cpu] = -1;
 334
 335         node = cpu_to_node(cpu);
 336
 337         LASSERT(node_isset(node, *cptab->ctb_parts[cpt].cpt_nodemask));
 338         LASSERT(node_isset(node, *cptab->ctb_nodemask));
 339
 340         for_each_cpu(i, cptab->ctb_parts[cpt].cpt_cpumask) {
 341                 /* this CPT has other CPU belonging to this node? */
 342                 if (cpu_to_node(i) == node)
 343                         break;
 344         }
 345
 346         if (i >= nr_cpu_ids)
 347                 node_clear(node, *cptab->ctb_parts[cpt].cpt_nodemask);
 348
 349         for_each_cpu(i, cptab->ctb_cpumask) {
 350                 /* this CPT-table has other CPU belonging to this node? */
 351                 if (cpu_to_node(i) == node)
 352                         break;
 353         }
 354
 355         if (i >= nr_cpu_ids)
 356                 node_clear(node, *cptab->ctb_nodemask);
 357 }
 358 EXPORT_SYMBOL(cfs_cpt_unset_cpu);
 359
 360 int
 361 cfs_cpt_set_cpumask(struct cfs_cpt_table *cptab, int cpt, cpumask_t *mask)
 362 {
 363         int     i;
 364
 365         if (cpumask_weight(mask) == 0 ||
 366             cpumask_any_and(mask, cpu_online_mask) >= nr_cpu_ids) {
 367                 CDEBUG(D_INFO, "No online CPU is found in the CPU mask for CPU partition %d\n",
 368                        cpt);
 369                 return 0;
 370         }
 371
 372         for_each_cpu(i, mask) {
 373                 if (!cfs_cpt_set_cpu(cptab, cpt, i))
 374                         return 0;
 375         }
 376
 377         return 1;
 378 }
 379 EXPORT_SYMBOL(cfs_cpt_set_cpumask);
 380
 381 void
 382 cfs_cpt_unset_cpumask(struct cfs_cpt_table *cptab, int cpt, cpumask_t *mask)
 383 {
 384         int     i;
 385
 386         for_each_cpu(i, mask)
 387                 cfs_cpt_unset_cpu(cptab, cpt, i);
 388 }
 389 EXPORT_SYMBOL(cfs_cpt_unset_cpumask);
 390
 391 int
 392 cfs_cpt_set_node(struct cfs_cpt_table *cptab, int cpt, int node)
 393 {
 394         cpumask_t       *mask;
 395         int             rc;
 396
 397         if (node < 0 || node >= MAX_NUMNODES) {
 398                 CDEBUG(D_INFO,
 399                        "Invalid NUMA id %d for CPU partition %d\n", node, cpt);
 400                 return 0;
 401         }
 402
 403         mutex_lock(&cpt_data.cpt_mutex);
 404
 405         mask = cpt_data.cpt_cpumask;
 406         cpumask_copy(mask, cpumask_of_node(node));
 407
 408         rc = cfs_cpt_set_cpumask(cptab, cpt, mask);
 409
 410         mutex_unlock(&cpt_data.cpt_mutex);
 411
 412         return rc;
 413 }
 414 EXPORT_SYMBOL(cfs_cpt_set_node);
 415
 416 void
 417 cfs_cpt_unset_node(struct cfs_cpt_table *cptab, int cpt, int node)
 418 {
 419         cpumask_t *mask;
 420
 421         if (node < 0 || node >= MAX_NUMNODES) {
 422                 CDEBUG(D_INFO,
 423                        "Invalid NUMA id %d for CPU partition %d\n", node, cpt);
 424                 return;
 425         }
 426
 427         mutex_lock(&cpt_data.cpt_mutex);
 428
 429         mask = cpt_data.cpt_cpumask;
 430         cpumask_copy(mask, cpumask_of_node(node));
 431
 432         cfs_cpt_unset_cpumask(cptab, cpt, mask);
 433
 434         mutex_unlock(&cpt_data.cpt_mutex);
 435 }
 436 EXPORT_SYMBOL(cfs_cpt_unset_node);
 437
 438 int
 439 cfs_cpt_set_nodemask(struct cfs_cpt_table *cptab, int cpt, nodemask_t *mask)
 440 {
 441         int     i;
 442
 443         for_each_node_mask(i, *mask) {
 444                 if (!cfs_cpt_set_node(cptab, cpt, i))
 445                         return 0;
 446         }
 447
 448         return 1;
 449 }
 450 EXPORT_SYMBOL(cfs_cpt_set_nodemask);
 451
 452 void
 453 cfs_cpt_unset_nodemask(struct cfs_cpt_table *cptab, int cpt, nodemask_t *mask)
 454 {
 455         int     i;
 456
 457         for_each_node_mask(i, *mask)
 458                 cfs_cpt_unset_node(cptab, cpt, i);
 459 }
 460 EXPORT_SYMBOL(cfs_cpt_unset_nodemask);
 461
 462 void
 463 cfs_cpt_clear(struct cfs_cpt_table *cptab, int cpt)
 464 {
 465         int     last;
 466         int     i;
 467
 468         if (cpt == CFS_CPT_ANY) {
 469                 last = cptab->ctb_nparts - 1;
 470                 cpt = 0;
 471         } else {
 472                 last = cpt;
 473         }
 474
 475         for (; cpt <= last; cpt++) {
 476                 for_each_cpu(i, cptab->ctb_parts[cpt].cpt_cpumask)
 477                         cfs_cpt_unset_cpu(cptab, cpt, i);
 478         }
 479 }
 480 EXPORT_SYMBOL(cfs_cpt_clear);
 481
 482 int
 483 cfs_cpt_spread_node(struct cfs_cpt_table *cptab, int cpt)
 484 {
 485         nodemask_t      *mask;
 486         int             weight;
 487         int             rotor;
 488         int             node;
 489
 490         /* convert CPU partition ID to HW node id */
 491
 492         if (cpt < 0 || cpt >= cptab->ctb_nparts) {
 493                 mask = cptab->ctb_nodemask;
 494                 rotor = cptab->ctb_spread_rotor++;
 495         } else {
 496                 mask = cptab->ctb_parts[cpt].cpt_nodemask;
 497                 rotor = cptab->ctb_parts[cpt].cpt_spread_rotor++;
 498         }
 499
 500         weight = nodes_weight(*mask);
 501         LASSERT(weight > 0);
 502
 503         rotor %= weight;
 504
 505         for_each_node_mask(node, *mask) {
 506                 if (rotor-- == 0)
 507                         return node;
 508         }
 509
 510         LBUG();
 511         return 0;
 512 }
 513 EXPORT_SYMBOL(cfs_cpt_spread_node);
 514
 515 int
 516 cfs_cpt_current(struct cfs_cpt_table *cptab, int remap)
 517 {
 518         int     cpu = smp_processor_id();
 519         int     cpt = cptab->ctb_cpu2cpt[cpu];
 520
 521         if (cpt < 0) {
 522                 if (!remap)
 523                         return cpt;
 524
 525                 /* don't return negative value for safety of upper layer,
 526                  * instead we shadow the unknown cpu to a valid partition ID
 527                  */
 528                 cpt = cpu % cptab->ctb_nparts;
 529         }
 530
 531         return cpt;
 532 }
 533 EXPORT_SYMBOL(cfs_cpt_current);
 534
 535 int
 536 cfs_cpt_of_cpu(struct cfs_cpt_table *cptab, int cpu)
 537 {
 538         LASSERT(cpu >= 0 && cpu < nr_cpu_ids);
 539
 540         return cptab->ctb_cpu2cpt[cpu];
 541 }
 542 EXPORT_SYMBOL(cfs_cpt_of_cpu);
 543
 544 int
 545 cfs_cpt_bind(struct cfs_cpt_table *cptab, int cpt)
 546 {
 547         cpumask_t       *cpumask;
 548         nodemask_t      *nodemask;
 549         int             rc;
 550         int             i;
 551
 552         LASSERT(cpt == CFS_CPT_ANY || (cpt >= 0 && cpt < cptab->ctb_nparts));
 553
 554         if (cpt == CFS_CPT_ANY) {
 555                 cpumask = cptab->ctb_cpumask;
 556                 nodemask = cptab->ctb_nodemask;
 557         } else {
 558                 cpumask = cptab->ctb_parts[cpt].cpt_cpumask;
 559                 nodemask = cptab->ctb_parts[cpt].cpt_nodemask;
 560         }
 561
 562         if (cpumask_any_and(cpumask, cpu_online_mask) >= nr_cpu_ids) {
 563                 CERROR("No online CPU found in CPU partition %d, did someone do CPU hotplug on system? You might need to reload Lustre modules to keep system working well.\n",
 564                        cpt);
 565                 return -EINVAL;
 566         }
 567
 568         for_each_online_cpu(i) {
 569                 if (cpumask_test_cpu(i, cpumask))
 570                         continue;
 571
 572                 rc = set_cpus_allowed_ptr(current, cpumask);
 573                 set_mems_allowed(*nodemask);
 574                 if (rc == 0)
 575                         schedule(); /* switch to allowed CPU */
 576
 577                 return rc;
 578         }
 579
 580         /* don't need to set affinity because all online CPUs are covered */
 581         return 0;
 582 }
 583 EXPORT_SYMBOL(cfs_cpt_bind);
 584
 585 /**
 586  * Choose max to \a number CPUs from \a node and set them in \a cpt.
 587  * We always prefer to choose CPU in the same core/socket.
 588  */
 589 static int
 590 cfs_cpt_choose_ncpus(struct cfs_cpt_table *cptab, int cpt,
 591                      cpumask_t *node, int number)
 592 {
 593         cpumask_t       *socket = NULL;
 594         cpumask_t       *core = NULL;
 595         int             rc = 0;
 596         int             cpu;
 597
 598         LASSERT(number > 0);
 599
 600         if (number >= cpumask_weight(node)) {
 601                 while (!cpumask_empty(node)) {
 602                         cpu = cpumask_first(node);
 603
 604                         rc = cfs_cpt_set_cpu(cptab, cpt, cpu);
 605                         if (!rc)
 606                                 return -EINVAL;
 607                         cpumask_clear_cpu(cpu, node);
 608                 }
 609                 return 0;
 610         }
 611
 612         /* allocate scratch buffer */
 613         LIBCFS_ALLOC(socket, cpumask_size());
 614         LIBCFS_ALLOC(core, cpumask_size());
 615         if (!socket || !core) {
 616                 rc = -ENOMEM;
 617                 goto out;
 618         }
 619
 620         while (!cpumask_empty(node)) {
 621                 cpu = cpumask_first(node);
 622
 623                 /* get cpumask for cores in the same socket */
 624                 cpumask_copy(socket, topology_core_cpumask(cpu));
 625                 cpumask_and(socket, socket, node);
 626
 627                 LASSERT(!cpumask_empty(socket));
 628
 629                 while (!cpumask_empty(socket)) {
 630                         int     i;
 631
 632                         /* get cpumask for hts in the same core */
 633                         cpumask_copy(core, topology_sibling_cpumask(cpu));
 634                         cpumask_and(core, core, node);
 635
 636                         LASSERT(!cpumask_empty(core));
 637
 638                         for_each_cpu(i, core) {
 639                                 cpumask_clear_cpu(i, socket);
 640                                 cpumask_clear_cpu(i, node);
 641
 642                                 rc = cfs_cpt_set_cpu(cptab, cpt, i);
 643                                 if (!rc) {
 644                                         rc = -EINVAL;
 645                                         goto out;
 646                                 }
 647
 648                                 if (--number == 0)
 649                                         goto out;
 650                         }
 651                         cpu = cpumask_first(socket);
 652                 }
 653         }
 654
 655  out:
 656         if (socket)
 657                 LIBCFS_FREE(socket, cpumask_size());
 658         if (core)
 659                 LIBCFS_FREE(core, cpumask_size());
 660         return rc;
 661 }
 662
 663 #define CPT_WEIGHT_MIN  4u
 664
 665 static unsigned int
 666 cfs_cpt_num_estimate(void)
 667 {
 668         unsigned nnode = num_online_nodes();
 669         unsigned ncpu  = num_online_cpus();
 670         unsigned ncpt;
 671
 672         if (ncpu <= CPT_WEIGHT_MIN) {
 673                 ncpt = 1;
 674                 goto out;
 675         }
 676
 677         /* generate reasonable number of CPU partitions based on total number
 678          * of CPUs, Preferred N should be power2 and match this condition:
 679          * 2 * (N - 1)^2 < NCPUS <= 2 * N^2
 680          */
 681         for (ncpt = 2; ncpu > 2 * ncpt * ncpt; ncpt <<= 1)
 682                 ;
 683
 684         if (ncpt <= nnode) { /* fat numa system */
 685                 while (nnode > ncpt)
 686                         nnode >>= 1;
 687
 688         } else { /* ncpt > nnode */
 689                 while ((nnode << 1) <= ncpt)
 690                         nnode <<= 1;
 691         }
 692
 693         ncpt = nnode;
 694
 695  out:
 696 #if (BITS_PER_LONG == 32)
 697         /* config many CPU partitions on 32-bit system could consume
 698          * too much memory
 699          */
 700         ncpt = min(2U, ncpt);
 701 #endif
 702         while (ncpu % ncpt != 0)
 703                 ncpt--; /* worst case is 1 */
 704
 705         return ncpt;
 706 }
 707
 708 static struct cfs_cpt_table *
 709 cfs_cpt_table_create(int ncpt)
 710 {
 711         struct cfs_cpt_table *cptab = NULL;
 712         cpumask_t       *mask = NULL;
 713         int             cpt = 0;
 714         int             num;
 715         int             rc;
 716         int             i;
 717
 718         rc = cfs_cpt_num_estimate();
 719         if (ncpt <= 0)
 720                 ncpt = rc;
 721
 722         if (ncpt > num_online_cpus() || ncpt > 4 * rc) {
 723                 CWARN("CPU partition number %d is larger than suggested value (%d), your system may have performance issue or run out of memory while under pressure\n",
 724                       ncpt, rc);
 725         }
 726
 727         if (num_online_cpus() % ncpt != 0) {
 728                 CERROR("CPU number %d is not multiple of cpu_npartition %d, please try different cpu_npartitions value or set pattern string by cpu_pattern=STRING\n",
 729                        (int)num_online_cpus(), ncpt);
 730                 goto failed;
 731         }
 732
 733         cptab = cfs_cpt_table_alloc(ncpt);
 734         if (!cptab) {
 735                 CERROR("Failed to allocate CPU map(%d)\n", ncpt);
 736                 goto failed;
 737         }
 738
 739         num = num_online_cpus() / ncpt;
 740         if (num == 0) {
 741                 CERROR("CPU changed while setting CPU partition\n");
 742                 goto failed;
 743         }
 744
 745         LIBCFS_ALLOC(mask, cpumask_size());
 746         if (!mask) {
 747                 CERROR("Failed to allocate scratch cpumask\n");
 748                 goto failed;
 749         }
 750
 751         for_each_online_node(i) {
 752                 cpumask_copy(mask, cpumask_of_node(i));
 753
 754                 while (!cpumask_empty(mask)) {
 755                         struct cfs_cpu_partition *part;
 756                         int    n;
 757
 758                         if (cpt >= ncpt)
 759                                 goto failed;
 760
 761                         part = &cptab->ctb_parts[cpt];
 762
 763                         n = num - cpumask_weight(part->cpt_cpumask);
 764                         LASSERT(n > 0);
 765
 766                         rc = cfs_cpt_choose_ncpus(cptab, cpt, mask, n);
 767                         if (rc < 0)
 768                                 goto failed;
 769
 770                         LASSERT(num >= cpumask_weight(part->cpt_cpumask));
 771                         if (num == cpumask_weight(part->cpt_cpumask))
 772                                 cpt++;
 773                 }
 774         }
 775
 776         if (cpt != ncpt ||
 777             num != cpumask_weight(cptab->ctb_parts[ncpt - 1].cpt_cpumask)) {
 778                 CERROR("Expect %d(%d) CPU partitions but got %d(%d), CPU hotplug/unplug while setting?\n",
 779                        cptab->ctb_nparts, num, cpt,
 780                        cpumask_weight(cptab->ctb_parts[ncpt - 1].cpt_cpumask));
 781                 goto failed;
 782         }
 783
 784         LIBCFS_FREE(mask, cpumask_size());
 785
 786         return cptab;
 787
 788  failed:
 789         CERROR("Failed to setup CPU-partition-table with %d CPU-partitions, online HW nodes: %d, HW cpus: %d.\n",
 790                ncpt, num_online_nodes(), num_online_cpus());
 791
 792         if (mask)
 793                 LIBCFS_FREE(mask, cpumask_size());
 794
 795         if (cptab)
 796                 cfs_cpt_table_free(cptab);
 797
 798         return NULL;
 799 }
 800
 801 static struct cfs_cpt_table *
 802 cfs_cpt_table_create_pattern(char *pattern)
 803 {
 804         struct cfs_cpt_table    *cptab;
 805         char                    *str    = pattern;
 806         int                     node    = 0;
 807         int                     high;
 808         int                     ncpt;
 809         int                     c;
 810
 811         for (ncpt = 0;; ncpt++) { /* quick scan bracket */
 812                 str = strchr(str, '[');
 813                 if (!str)
 814                         break;
 815                 str++;
 816         }
 817
 818         str = cfs_trimwhite(pattern);
 819         if (*str == 'n' || *str == 'N') {
 820                 pattern = str + 1;
 821                 node = 1;
 822         }
 823
 824         if (ncpt == 0 ||
 825             (node && ncpt > num_online_nodes()) ||
 826             (!node && ncpt > num_online_cpus())) {
 827                 CERROR("Invalid pattern %s, or too many partitions %d\n",
 828                        pattern, ncpt);
 829                 return NULL;
 830         }
 831
 832         high = node ? MAX_NUMNODES - 1 : nr_cpu_ids - 1;
 833
 834         cptab = cfs_cpt_table_alloc(ncpt);
 835         if (!cptab) {
 836                 CERROR("Failed to allocate cpu partition table\n");
 837                 return NULL;
 838         }
 839
 840         for (str = cfs_trimwhite(pattern), c = 0;; c++) {
 841                 struct cfs_range_expr   *range;
 842                 struct cfs_expr_list    *el;
 843                 char                    *bracket = strchr(str, '[');
 844                 int                     cpt;
 845                 int                     rc;
 846                 int                     i;
 847                 int                     n;
 848
 849                 if (!bracket) {
 850                         if (*str != 0) {
 851                                 CERROR("Invalid pattern %s\n", str);
 852                                 goto failed;
 853                         }
 854                         if (c != ncpt) {
 855                                 CERROR("expect %d partitions but found %d\n",
 856                                        ncpt, c);
 857                                 goto failed;
 858                         }
 859                         break;
 860                 }
 861
 862                 if (sscanf(str, "%d%n", &cpt, &n) < 1) {
 863                         CERROR("Invalid cpu pattern %s\n", str);
 864                         goto failed;
 865                 }
 866
 867                 if (cpt < 0 || cpt >= ncpt) {
 868                         CERROR("Invalid partition id %d, total partitions %d\n",
 869                                cpt, ncpt);
 870                         goto failed;
 871                 }
 872
 873                 if (cfs_cpt_weight(cptab, cpt) != 0) {
 874                         CERROR("Partition %d has already been set.\n", cpt);
 875                         goto failed;
 876                 }
 877
 878                 str = cfs_trimwhite(str + n);
 879                 if (str != bracket) {
 880                         CERROR("Invalid pattern %s\n", str);
 881                         goto failed;
 882                 }
 883
 884                 bracket = strchr(str, ']');
 885                 if (!bracket) {
 886                         CERROR("missing right bracket for cpt %d, %s\n",
 887                                cpt, str);
 888                         goto failed;
 889                 }
 890
 891                 if (cfs_expr_list_parse(str, (bracket - str) + 1,
 892                                         0, high, &el) != 0) {
 893                         CERROR("Can't parse number range: %s\n", str);
 894                         goto failed;
 895                 }
 896
 897                 list_for_each_entry(range, &el->el_exprs, re_link) {
 898                         for (i = range->re_lo; i <= range->re_hi; i++) {
 899                                 if ((i - range->re_lo) % range->re_stride != 0)
 900                                         continue;
 901
 902                                 rc = node ? cfs_cpt_set_node(cptab, cpt, i) :
 903                                             cfs_cpt_set_cpu(cptab, cpt, i);
 904                                 if (!rc) {
 905                                         cfs_expr_list_free(el);
 906                                         goto failed;
 907                                 }
 908                         }
 909                 }
 910
 911                 cfs_expr_list_free(el);
 912
 913                 if (!cfs_cpt_online(cptab, cpt)) {
 914                         CERROR("No online CPU is found on partition %d\n", cpt);
 915                         goto failed;
 916                 }
 917
 918                 str = cfs_trimwhite(bracket + 1);
 919         }
 920
 921         return cptab;
 922
 923  failed:
 924         cfs_cpt_table_free(cptab);
 925         return NULL;
 926 }
 927
 928 #ifdef CONFIG_HOTPLUG_CPU
 929 static int
 930 cfs_cpu_notify(struct notifier_block *self, unsigned long action, void *hcpu)
 931 {
 932         unsigned int  cpu = (unsigned long)hcpu;
 933         bool         warn;
 934
 935         switch (action) {
 936         case CPU_DEAD:
 937         case CPU_DEAD_FROZEN:
 938         case CPU_ONLINE:
 939         case CPU_ONLINE_FROZEN:
 940                 spin_lock(&cpt_data.cpt_lock);
 941                 cpt_data.cpt_version++;
 942                 spin_unlock(&cpt_data.cpt_lock);
 943                 /* Fall through */
 944         default:
 945                 if (action != CPU_DEAD && action != CPU_DEAD_FROZEN) {
 946                         CDEBUG(D_INFO, "CPU changed [cpu %u action %lx]\n",
 947                                cpu, action);
 948                         break;
 949                 }
 950
 951                 mutex_lock(&cpt_data.cpt_mutex);
 952                 /* if all HTs in a core are offline, it may break affinity */
 953                 cpumask_copy(cpt_data.cpt_cpumask,
 954                              topology_sibling_cpumask(cpu));
 955                 warn = cpumask_any_and(cpt_data.cpt_cpumask,
 956                                        cpu_online_mask) >= nr_cpu_ids;
 957                 mutex_unlock(&cpt_data.cpt_mutex);
 958                 CDEBUG(warn ? D_WARNING : D_INFO,
 959                        "Lustre: can't support CPU plug-out well now, performance and stability could be impacted [CPU %u action: %lx]\n",
 960                        cpu, action);
 961         }
 962
 963         return NOTIFY_OK;
 964 }
 965
 966 static struct notifier_block cfs_cpu_notifier = {
 967         .notifier_call  = cfs_cpu_notify,
 968         .priority       = 0
 969 };
 970
 971 #endif
 972
 973 void
 974 cfs_cpu_fini(void)
 975 {
 976         if (cfs_cpt_table)
 977                 cfs_cpt_table_free(cfs_cpt_table);
 978
 979 #ifdef CONFIG_HOTPLUG_CPU
 980         unregister_hotcpu_notifier(&cfs_cpu_notifier);
 981 #endif
 982         if (cpt_data.cpt_cpumask)
 983                 LIBCFS_FREE(cpt_data.cpt_cpumask, cpumask_size());
 984 }
 985
 986 int
 987 cfs_cpu_init(void)
 988 {
 989         LASSERT(!cfs_cpt_table);
 990
 991         memset(&cpt_data, 0, sizeof(cpt_data));
 992
 993         LIBCFS_ALLOC(cpt_data.cpt_cpumask, cpumask_size());
 994         if (!cpt_data.cpt_cpumask) {
 995                 CERROR("Failed to allocate scratch buffer\n");
 996                 return -1;
 997         }
 998
 999         spin_lock_init(&cpt_data.cpt_lock);
1000         mutex_init(&cpt_data.cpt_mutex);
1001
1002 #ifdef CONFIG_HOTPLUG_CPU
1003         register_hotcpu_notifier(&cfs_cpu_notifier);
1004 #endif
1005
1006         if (*cpu_pattern != 0) {
1007                 cfs_cpt_table = cfs_cpt_table_create_pattern(cpu_pattern);
1008                 if (!cfs_cpt_table) {
1009                         CERROR("Failed to create cptab from pattern %s\n",
1010                                cpu_pattern);
1011                         goto failed;
1012                 }
1013
1014         } else {
1015                 cfs_cpt_table = cfs_cpt_table_create(cpu_npartitions);
1016                 if (!cfs_cpt_table) {
1017                         CERROR("Failed to create ptable with npartitions %d\n",
1018                                cpu_npartitions);
1019                         goto failed;
1020                 }
1021         }
1022
1023         spin_lock(&cpt_data.cpt_lock);
1024         if (cfs_cpt_table->ctb_version != cpt_data.cpt_version) {
1025                 spin_unlock(&cpt_data.cpt_lock);
1026                 CERROR("CPU hotplug/unplug during setup\n");
1027                 goto failed;
1028         }
1029         spin_unlock(&cpt_data.cpt_lock);
1030
1031         LCONSOLE(0, "HW CPU cores: %d, npartitions: %d\n",
1032                  num_online_cpus(), cfs_cpt_number(cfs_cpt_table));
1033         return 0;
1034
1035  failed:
1036         cfs_cpu_fini();
1037         return -1;
1038 }
1039
1040 #endif