arch/tile/kernel/hardwall.c

   1 /*
   2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  */
  14
  15 #include <linux/fs.h>
  16 #include <linux/proc_fs.h>
  17 #include <linux/seq_file.h>
  18 #include <linux/rwsem.h>
  19 #include <linux/kprobes.h>
  20 #include <linux/sched.h>
  21 #include <linux/hardirq.h>
  22 #include <linux/uaccess.h>
  23 #include <linux/smp.h>
  24 #include <linux/cdev.h>
  25 #include <linux/compat.h>
  26 #include <asm/hardwall.h>
  27 #include <asm/traps.h>
  28 #include <asm/siginfo.h>
  29 #include <asm/irq_regs.h>
  30
  31 #include <arch/interrupts.h>
  32 #include <arch/spr_def.h>
  33
  34
  35 /*
  36  * This data structure tracks the rectangle data, etc., associated
  37  * one-to-one with a "struct file *" from opening HARDWALL_FILE.
  38  * Note that the file's private data points back to this structure.
  39  */
  40 struct hardwall_info {
  41         struct list_head list;             /* "rectangles" list */
  42         struct list_head task_head;        /* head of tasks in this hardwall */
  43         int ulhc_x;                        /* upper left hand corner x coord */
  44         int ulhc_y;                        /* upper left hand corner y coord */
  45         int width;                         /* rectangle width */
  46         int height;                        /* rectangle height */
  47         int teardown_in_progress;          /* are we tearing this one down? */
  48 };
  49
  50 /* Currently allocated hardwall rectangles */
  51 static LIST_HEAD(rectangles);
  52
  53 /*
  54  * Guard changes to the hardwall data structures.
  55  * This could be finer grained (e.g. one lock for the list of hardwall
  56  * rectangles, then separate embedded locks for each one's list of tasks),
  57  * but there are subtle correctness issues when trying to start with
  58  * a task's "hardwall" pointer and lock the correct rectangle's embedded
  59  * lock in the presence of a simultaneous deactivation, so it seems
  60  * easier to have a single lock, given that none of these data
  61  * structures are touched very frequently during normal operation.
  62  */
  63 static DEFINE_SPINLOCK(hardwall_lock);
  64
  65 /* Allow disabling UDN access. */
  66 static int udn_disabled;
  67 static int __init noudn(char *str)
  68 {
  69         pr_info("User-space UDN access is disabled\n");
  70         udn_disabled = 1;
  71         return 0;
  72 }
  73 early_param("noudn", noudn);
  74
  75
  76 /*
  77  * Low-level primitives
  78  */
  79
  80 /* Set a CPU bit if the CPU is online. */
  81 #define cpu_online_set(cpu, dst) do { \
  82         if (cpu_online(cpu))          \
  83                 cpumask_set_cpu(cpu, dst);    \
  84 } while (0)
  85
  86
  87 /* Does the given rectangle contain the given x,y coordinate? */
  88 static int contains(struct hardwall_info *r, int x, int y)
  89 {
  90         return (x >= r->ulhc_x && x < r->ulhc_x + r->width) &&
  91                 (y >= r->ulhc_y && y < r->ulhc_y + r->height);
  92 }
  93
  94 /* Compute the rectangle parameters and validate the cpumask. */
  95 static int setup_rectangle(struct hardwall_info *r, struct cpumask *mask)
  96 {
  97         int x, y, cpu, ulhc, lrhc;
  98
  99         /* The first cpu is the ULHC, the last the LRHC. */
 100         ulhc = find_first_bit(cpumask_bits(mask), nr_cpumask_bits);
 101         lrhc = find_last_bit(cpumask_bits(mask), nr_cpumask_bits);
 102
 103         /* Compute the rectangle attributes from the cpus. */
 104         r->ulhc_x = cpu_x(ulhc);
 105         r->ulhc_y = cpu_y(ulhc);
 106         r->width = cpu_x(lrhc) - r->ulhc_x + 1;
 107         r->height = cpu_y(lrhc) - r->ulhc_y + 1;
 108
 109         /* Width and height must be positive */
 110         if (r->width <= 0 || r->height <= 0)
 111                 return -EINVAL;
 112
 113         /* Confirm that the cpumask is exactly the rectangle. */
 114         for (y = 0, cpu = 0; y < smp_height; ++y)
 115                 for (x = 0; x < smp_width; ++x, ++cpu)
 116                         if (cpumask_test_cpu(cpu, mask) != contains(r, x, y))
 117                                 return -EINVAL;
 118
 119         /*
 120          * Note that offline cpus can't be drained when this UDN
 121          * rectangle eventually closes.  We used to detect this
 122          * situation and print a warning, but it annoyed users and
 123          * they ignored it anyway, so now we just return without a
 124          * warning.
 125          */
 126         return 0;
 127 }
 128
 129 /* Do the two given rectangles overlap on any cpu? */
 130 static int overlaps(struct hardwall_info *a, struct hardwall_info *b)
 131 {
 132         return a->ulhc_x + a->width > b->ulhc_x &&    /* A not to the left */
 133                 b->ulhc_x + b->width > a->ulhc_x &&   /* B not to the left */
 134                 a->ulhc_y + a->height > b->ulhc_y &&  /* A not above */
 135                 b->ulhc_y + b->height > a->ulhc_y;    /* B not above */
 136 }
 137
 138
 139 /*
 140  * Hardware management of hardwall setup, teardown, trapping,
 141  * and enabling/disabling PL0 access to the networks.
 142  */
 143
 144 /* Bit field values to mask together for writes to SPR_XDN_DIRECTION_PROTECT */
 145 enum direction_protect {
 146         N_PROTECT = (1 << 0),
 147         E_PROTECT = (1 << 1),
 148         S_PROTECT = (1 << 2),
 149         W_PROTECT = (1 << 3)
 150 };
 151
 152 static void enable_firewall_interrupts(void)
 153 {
 154         arch_local_irq_unmask_now(INT_UDN_FIREWALL);
 155 }
 156
 157 static void disable_firewall_interrupts(void)
 158 {
 159         arch_local_irq_mask_now(INT_UDN_FIREWALL);
 160 }
 161
 162 /* Set up hardwall on this cpu based on the passed hardwall_info. */
 163 static void hardwall_setup_ipi_func(void *info)
 164 {
 165         struct hardwall_info *r = info;
 166         int cpu = smp_processor_id();
 167         int x = cpu % smp_width;
 168         int y = cpu / smp_width;
 169         int bits = 0;
 170         if (x == r->ulhc_x)
 171                 bits |= W_PROTECT;
 172         if (x == r->ulhc_x + r->width - 1)
 173                 bits |= E_PROTECT;
 174         if (y == r->ulhc_y)
 175                 bits |= N_PROTECT;
 176         if (y == r->ulhc_y + r->height - 1)
 177                 bits |= S_PROTECT;
 178         BUG_ON(bits == 0);
 179         __insn_mtspr(SPR_UDN_DIRECTION_PROTECT, bits);
 180         enable_firewall_interrupts();
 181
 182 }
 183
 184 /* Set up all cpus on edge of rectangle to enable/disable hardwall SPRs. */
 185 static void hardwall_setup(struct hardwall_info *r)
 186 {
 187         int x, y, cpu, delta;
 188         struct cpumask rect_cpus;
 189
 190         cpumask_clear(&rect_cpus);
 191
 192         /* First include the top and bottom edges */
 193         cpu = r->ulhc_y * smp_width + r->ulhc_x;
 194         delta = (r->height - 1) * smp_width;
 195         for (x = 0; x < r->width; ++x, ++cpu) {
 196                 cpu_online_set(cpu, &rect_cpus);
 197                 cpu_online_set(cpu + delta, &rect_cpus);
 198         }
 199
 200         /* Then the left and right edges */
 201         cpu -= r->width;
 202         delta = r->width - 1;
 203         for (y = 0; y < r->height; ++y, cpu += smp_width) {
 204                 cpu_online_set(cpu, &rect_cpus);
 205                 cpu_online_set(cpu + delta, &rect_cpus);
 206         }
 207
 208         /* Then tell all the cpus to set up their protection SPR */
 209         on_each_cpu_mask(&rect_cpus, hardwall_setup_ipi_func, r, 1);
 210 }
 211
 212 void __kprobes do_hardwall_trap(struct pt_regs* regs, int fault_num)
 213 {
 214         struct hardwall_info *rect;
 215         struct task_struct *p;
 216         struct siginfo info;
 217         int x, y;
 218         int cpu = smp_processor_id();
 219         int found_processes;
 220         unsigned long flags;
 221
 222         struct pt_regs *old_regs = set_irq_regs(regs);
 223         irq_enter();
 224
 225         /* This tile trapped a network access; find the rectangle. */
 226         x = cpu % smp_width;
 227         y = cpu / smp_width;
 228         spin_lock_irqsave(&hardwall_lock, flags);
 229         list_for_each_entry(rect, &rectangles, list) {
 230                 if (contains(rect, x, y))
 231                         break;
 232         }
 233
 234         /*
 235          * It shouldn't be possible not to find this cpu on the
 236          * rectangle list, since only cpus in rectangles get hardwalled.
 237          * The hardwall is only removed after the UDN is drained.
 238          */
 239         BUG_ON(&rect->list == &rectangles);
 240
 241         /*
 242          * If we already started teardown on this hardwall, don't worry;
 243          * the abort signal has been sent and we are just waiting for things
 244          * to quiesce.
 245          */
 246         if (rect->teardown_in_progress) {
 247                 pr_notice("cpu %d: detected hardwall violation %#lx"
 248                        " while teardown already in progress\n",
 249                        cpu, (long) __insn_mfspr(SPR_UDN_DIRECTION_PROTECT));
 250                 goto done;
 251         }
 252
 253         /*
 254          * Kill off any process that is activated in this rectangle.
 255          * We bypass security to deliver the signal, since it must be
 256          * one of the activated processes that generated the UDN
 257          * message that caused this trap, and all the activated
 258          * processes shared a single open file so are pretty tightly
 259          * bound together from a security point of view to begin with.
 260          */
 261         rect->teardown_in_progress = 1;
 262         wmb(); /* Ensure visibility of rectangle before notifying processes. */
 263         pr_notice("cpu %d: detected hardwall violation %#lx...\n",
 264                cpu, (long) __insn_mfspr(SPR_UDN_DIRECTION_PROTECT));
 265         info.si_signo = SIGILL;
 266         info.si_errno = 0;
 267         info.si_code = ILL_HARDWALL;
 268         found_processes = 0;
 269         list_for_each_entry(p, &rect->task_head, thread.hardwall_list) {
 270                 BUG_ON(p->thread.hardwall != rect);
 271                 if (!(p->flags & PF_EXITING)) {
 272                         found_processes = 1;
 273                         pr_notice("hardwall: killing %d\n", p->pid);
 274                         do_send_sig_info(info.si_signo, &info, p, false);
 275                 }
 276         }
 277         if (!found_processes)
 278                 pr_notice("hardwall: no associated processes!\n");
 279
 280  done:
 281         spin_unlock_irqrestore(&hardwall_lock, flags);
 282
 283         /*
 284          * We have to disable firewall interrupts now, or else when we
 285          * return from this handler, we will simply re-interrupt back to
 286          * it.  However, we can't clear the protection bits, since we
 287          * haven't yet drained the network, and that would allow packets
 288          * to cross out of the hardwall region.
 289          */
 290         disable_firewall_interrupts();
 291
 292         irq_exit();
 293         set_irq_regs(old_regs);
 294 }
 295
 296 /* Allow access from user space to the UDN. */
 297 void grant_network_mpls(void)
 298 {
 299         __insn_mtspr(SPR_MPL_UDN_ACCESS_SET_0, 1);
 300         __insn_mtspr(SPR_MPL_UDN_AVAIL_SET_0, 1);
 301         __insn_mtspr(SPR_MPL_UDN_COMPLETE_SET_0, 1);
 302         __insn_mtspr(SPR_MPL_UDN_TIMER_SET_0, 1);
 303 #if !CHIP_HAS_REV1_XDN()
 304         __insn_mtspr(SPR_MPL_UDN_REFILL_SET_0, 1);
 305         __insn_mtspr(SPR_MPL_UDN_CA_SET_0, 1);
 306 #endif
 307 }
 308
 309 /* Deny access from user space to the UDN. */
 310 void restrict_network_mpls(void)
 311 {
 312         __insn_mtspr(SPR_MPL_UDN_ACCESS_SET_1, 1);
 313         __insn_mtspr(SPR_MPL_UDN_AVAIL_SET_1, 1);
 314         __insn_mtspr(SPR_MPL_UDN_COMPLETE_SET_1, 1);
 315         __insn_mtspr(SPR_MPL_UDN_TIMER_SET_1, 1);
 316 #if !CHIP_HAS_REV1_XDN()
 317         __insn_mtspr(SPR_MPL_UDN_REFILL_SET_1, 1);
 318         __insn_mtspr(SPR_MPL_UDN_CA_SET_1, 1);
 319 #endif
 320 }
 321
 322
 323 /*
 324  * Code to create, activate, deactivate, and destroy hardwall rectangles.
 325  */
 326
 327 /* Create a hardwall for the given rectangle */
 328 static struct hardwall_info *hardwall_create(
 329         size_t size, const unsigned char __user *bits)
 330 {
 331         struct hardwall_info *iter, *rect;
 332         struct cpumask mask;
 333         unsigned long flags;
 334         int rc;
 335
 336         /* Reject crazy sizes out of hand, a la sys_mbind(). */
 337         if (size > PAGE_SIZE)
 338                 return ERR_PTR(-EINVAL);
 339
 340         /* Copy whatever fits into a cpumask. */
 341         if (copy_from_user(&mask, bits, min(sizeof(struct cpumask), size)))
 342                 return ERR_PTR(-EFAULT);
 343
 344         /*
 345          * If the size was short, clear the rest of the mask;
 346          * otherwise validate that the rest of the user mask was zero
 347          * (we don't try hard to be efficient when validating huge masks).
 348          */
 349         if (size < sizeof(struct cpumask)) {
 350                 memset((char *)&mask + size, 0, sizeof(struct cpumask) - size);
 351         } else if (size > sizeof(struct cpumask)) {
 352                 size_t i;
 353                 for (i = sizeof(struct cpumask); i < size; ++i) {
 354                         char c;
 355                         if (get_user(c, &bits[i]))
 356                                 return ERR_PTR(-EFAULT);
 357                         if (c)
 358                                 return ERR_PTR(-EINVAL);
 359                 }
 360         }
 361
 362         /* Allocate a new rectangle optimistically. */
 363         rect = kmalloc(sizeof(struct hardwall_info),
 364                         GFP_KERNEL | __GFP_ZERO);
 365         if (rect == NULL)
 366                 return ERR_PTR(-ENOMEM);
 367         INIT_LIST_HEAD(&rect->task_head);
 368
 369         /* Compute the rectangle size and validate that it's plausible. */
 370         rc = setup_rectangle(rect, &mask);
 371         if (rc != 0) {
 372                 kfree(rect);
 373                 return ERR_PTR(rc);
 374         }
 375
 376         /* Confirm it doesn't overlap and add it to the list. */
 377         spin_lock_irqsave(&hardwall_lock, flags);
 378         list_for_each_entry(iter, &rectangles, list) {
 379                 if (overlaps(iter, rect)) {
 380                         spin_unlock_irqrestore(&hardwall_lock, flags);
 381                         kfree(rect);
 382                         return ERR_PTR(-EBUSY);
 383                 }
 384         }
 385         list_add_tail(&rect->list, &rectangles);
 386         spin_unlock_irqrestore(&hardwall_lock, flags);
 387
 388         /* Set up appropriate hardwalling on all affected cpus. */
 389         hardwall_setup(rect);
 390
 391         return rect;
 392 }
 393
 394 /* Activate a given hardwall on this cpu for this process. */
 395 static int hardwall_activate(struct hardwall_info *rect)
 396 {
 397         int cpu, x, y;
 398         unsigned long flags;
 399         struct task_struct *p = current;
 400         struct thread_struct *ts = &p->thread;
 401
 402         /* Require a rectangle. */
 403         if (rect == NULL)
 404                 return -ENODATA;
 405
 406         /* Not allowed to activate a rectangle that is being torn down. */
 407         if (rect->teardown_in_progress)
 408                 return -EINVAL;
 409
 410         /*
 411          * Get our affinity; if we're not bound to this tile uniquely,
 412          * we can't access the network registers.
 413          */
 414         if (cpumask_weight(&p->cpus_allowed) != 1)
 415                 return -EPERM;
 416
 417         /* Make sure we are bound to a cpu in this rectangle. */
 418         cpu = smp_processor_id();
 419         BUG_ON(cpumask_first(&p->cpus_allowed) != cpu);
 420         x = cpu_x(cpu);
 421         y = cpu_y(cpu);
 422         if (!contains(rect, x, y))
 423                 return -EINVAL;
 424
 425         /* If we are already bound to this hardwall, it's a no-op. */
 426         if (ts->hardwall) {
 427                 BUG_ON(ts->hardwall != rect);
 428                 return 0;
 429         }
 430
 431         /* Success!  This process gets to use the user networks on this cpu. */
 432         ts->hardwall = rect;
 433         spin_lock_irqsave(&hardwall_lock, flags);
 434         list_add(&ts->hardwall_list, &rect->task_head);
 435         spin_unlock_irqrestore(&hardwall_lock, flags);
 436         grant_network_mpls();
 437         printk(KERN_DEBUG "Pid %d (%s) activated for hardwall: cpu %d\n",
 438                p->pid, p->comm, cpu);
 439         return 0;
 440 }
 441
 442 /*
 443  * Deactivate a task's hardwall.  Must hold hardwall_lock.
 444  * This method may be called from free_task(), so we don't want to
 445  * rely on too many fields of struct task_struct still being valid.
 446  * We assume the cpus_allowed, pid, and comm fields are still valid.
 447  */
 448 static void _hardwall_deactivate(struct task_struct *task)
 449 {
 450         struct thread_struct *ts = &task->thread;
 451
 452         if (cpumask_weight(&task->cpus_allowed) != 1) {
 453                 pr_err("pid %d (%s) releasing networks with"
 454                        " an affinity mask containing %d cpus!\n",
 455                        task->pid, task->comm,
 456                        cpumask_weight(&task->cpus_allowed));
 457                 BUG();
 458         }
 459
 460         BUG_ON(ts->hardwall == NULL);
 461         ts->hardwall = NULL;
 462         list_del(&ts->hardwall_list);
 463         if (task == current)
 464                 restrict_network_mpls();
 465 }
 466
 467 /* Deactivate a task's hardwall. */
 468 int hardwall_deactivate(struct task_struct *task)
 469 {
 470         unsigned long flags;
 471         int activated;
 472
 473         spin_lock_irqsave(&hardwall_lock, flags);
 474         activated = (task->thread.hardwall != NULL);
 475         if (activated)
 476                 _hardwall_deactivate(task);
 477         spin_unlock_irqrestore(&hardwall_lock, flags);
 478
 479         if (!activated)
 480                 return -EINVAL;
 481
 482         printk(KERN_DEBUG "Pid %d (%s) deactivated for hardwall: cpu %d\n",
 483                task->pid, task->comm, smp_processor_id());
 484         return 0;
 485 }
 486
 487 /* Stop a UDN switch before draining the network. */
 488 static void stop_udn_switch(void *ignored)
 489 {
 490 #if !CHIP_HAS_REV1_XDN()
 491         /* Freeze the switch and the demux. */
 492         __insn_mtspr(SPR_UDN_SP_FREEZE,
 493                      SPR_UDN_SP_FREEZE__SP_FRZ_MASK |
 494                      SPR_UDN_SP_FREEZE__DEMUX_FRZ_MASK |
 495                      SPR_UDN_SP_FREEZE__NON_DEST_EXT_MASK);
 496 #endif
 497 }
 498
 499 /* Drain all the state from a stopped switch. */
 500 static void drain_udn_switch(void *ignored)
 501 {
 502 #if !CHIP_HAS_REV1_XDN()
 503         int i;
 504         int from_tile_words, ca_count;
 505
 506         /* Empty out the 5 switch point fifos. */
 507         for (i = 0; i < 5; i++) {
 508                 int words, j;
 509                 __insn_mtspr(SPR_UDN_SP_FIFO_SEL, i);
 510                 words = __insn_mfspr(SPR_UDN_SP_STATE) & 0xF;
 511                 for (j = 0; j < words; j++)
 512                         (void) __insn_mfspr(SPR_UDN_SP_FIFO_DATA);
 513                 BUG_ON((__insn_mfspr(SPR_UDN_SP_STATE) & 0xF) != 0);
 514         }
 515
 516         /* Dump out the 3 word fifo at top. */
 517         from_tile_words = (__insn_mfspr(SPR_UDN_DEMUX_STATUS) >> 10) & 0x3;
 518         for (i = 0; i < from_tile_words; i++)
 519                 (void) __insn_mfspr(SPR_UDN_DEMUX_WRITE_FIFO);
 520
 521         /* Empty out demuxes. */
 522         while (__insn_mfspr(SPR_UDN_DATA_AVAIL) & (1 << 0))
 523                 (void) __tile_udn0_receive();
 524         while (__insn_mfspr(SPR_UDN_DATA_AVAIL) & (1 << 1))
 525                 (void) __tile_udn1_receive();
 526         while (__insn_mfspr(SPR_UDN_DATA_AVAIL) & (1 << 2))
 527                 (void) __tile_udn2_receive();
 528         while (__insn_mfspr(SPR_UDN_DATA_AVAIL) & (1 << 3))
 529                 (void) __tile_udn3_receive();
 530         BUG_ON((__insn_mfspr(SPR_UDN_DATA_AVAIL) & 0xF) != 0);
 531
 532         /* Empty out catch all. */
 533         ca_count = __insn_mfspr(SPR_UDN_DEMUX_CA_COUNT);
 534         for (i = 0; i < ca_count; i++)
 535                 (void) __insn_mfspr(SPR_UDN_CA_DATA);
 536         BUG_ON(__insn_mfspr(SPR_UDN_DEMUX_CA_COUNT) != 0);
 537
 538         /* Clear demux logic. */
 539         __insn_mtspr(SPR_UDN_DEMUX_CTL, 1);
 540
 541         /*
 542          * Write switch state; experimentation indicates that 0xc3000
 543          * is an idle switch point.
 544          */
 545         for (i = 0; i < 5; i++) {
 546                 __insn_mtspr(SPR_UDN_SP_FIFO_SEL, i);
 547                 __insn_mtspr(SPR_UDN_SP_STATE, 0xc3000);
 548         }
 549 #endif
 550 }
 551
 552 /* Reset random UDN state registers at boot up and during hardwall teardown. */
 553 void reset_network_state(void)
 554 {
 555 #if !CHIP_HAS_REV1_XDN()
 556         /* Reset UDN coordinates to their standard value */
 557         unsigned int cpu = smp_processor_id();
 558         unsigned int x = cpu % smp_width;
 559         unsigned int y = cpu / smp_width;
 560 #endif
 561
 562         if (udn_disabled)
 563                 return;
 564
 565 #if !CHIP_HAS_REV1_XDN()
 566         __insn_mtspr(SPR_UDN_TILE_COORD, (x << 18) | (y << 7));
 567
 568         /* Set demux tags to predefined values and enable them. */
 569         __insn_mtspr(SPR_UDN_TAG_VALID, 0xf);
 570         __insn_mtspr(SPR_UDN_TAG_0, (1 << 0));
 571         __insn_mtspr(SPR_UDN_TAG_1, (1 << 1));
 572         __insn_mtspr(SPR_UDN_TAG_2, (1 << 2));
 573         __insn_mtspr(SPR_UDN_TAG_3, (1 << 3));
 574 #endif
 575
 576         /* Clear out other random registers so we have a clean slate. */
 577         __insn_mtspr(SPR_UDN_AVAIL_EN, 0);
 578         __insn_mtspr(SPR_UDN_DEADLOCK_TIMEOUT, 0);
 579 #if !CHIP_HAS_REV1_XDN()
 580         __insn_mtspr(SPR_UDN_REFILL_EN, 0);
 581         __insn_mtspr(SPR_UDN_DEMUX_QUEUE_SEL, 0);
 582         __insn_mtspr(SPR_UDN_SP_FIFO_SEL, 0);
 583 #endif
 584
 585         /* Start the switch and demux. */
 586 #if !CHIP_HAS_REV1_XDN()
 587         __insn_mtspr(SPR_UDN_SP_FREEZE, 0);
 588 #endif
 589 }
 590
 591 /* Restart a UDN switch after draining. */
 592 static void restart_udn_switch(void *ignored)
 593 {
 594         reset_network_state();
 595
 596         /* Disable firewall interrupts. */
 597         __insn_mtspr(SPR_UDN_DIRECTION_PROTECT, 0);
 598         disable_firewall_interrupts();
 599 }
 600
 601 /* Build a struct cpumask containing all valid tiles in bounding rectangle. */
 602 static void fill_mask(struct hardwall_info *r, struct cpumask *result)
 603 {
 604         int x, y, cpu;
 605
 606         cpumask_clear(result);
 607
 608         cpu = r->ulhc_y * smp_width + r->ulhc_x;
 609         for (y = 0; y < r->height; ++y, cpu += smp_width - r->width) {
 610                 for (x = 0; x < r->width; ++x, ++cpu)
 611                         cpu_online_set(cpu, result);
 612         }
 613 }
 614
 615 /* Last reference to a hardwall is gone, so clear the network. */
 616 static void hardwall_destroy(struct hardwall_info *rect)
 617 {
 618         struct task_struct *task;
 619         unsigned long flags;
 620         struct cpumask mask;
 621
 622         /* Make sure this file actually represents a rectangle. */
 623         if (rect == NULL)
 624                 return;
 625
 626         /*
 627          * Deactivate any remaining tasks.  It's possible to race with
 628          * some other thread that is exiting and hasn't yet called
 629          * deactivate (when freeing its thread_info), so we carefully
 630          * deactivate any remaining tasks before freeing the
 631          * hardwall_info object itself.
 632          */
 633         spin_lock_irqsave(&hardwall_lock, flags);
 634         list_for_each_entry(task, &rect->task_head, thread.hardwall_list)
 635                 _hardwall_deactivate(task);
 636         spin_unlock_irqrestore(&hardwall_lock, flags);
 637
 638         /* Drain the UDN. */
 639         printk(KERN_DEBUG "Clearing hardwall rectangle %dx%d %d,%d\n",
 640                rect->width, rect->height, rect->ulhc_x, rect->ulhc_y);
 641         fill_mask(rect, &mask);
 642         on_each_cpu_mask(&mask, stop_udn_switch, NULL, 1);
 643         on_each_cpu_mask(&mask, drain_udn_switch, NULL, 1);
 644
 645         /* Restart switch and disable firewall. */
 646         on_each_cpu_mask(&mask, restart_udn_switch, NULL, 1);
 647
 648         /* Now free the rectangle from the list. */
 649         spin_lock_irqsave(&hardwall_lock, flags);
 650         BUG_ON(!list_empty(&rect->task_head));
 651         list_del(&rect->list);
 652         spin_unlock_irqrestore(&hardwall_lock, flags);
 653         kfree(rect);
 654 }
 655
 656
 657 /*
 658  * Dump hardwall state via /proc; initialized in arch/tile/sys/proc.c.
 659  */
 660 int proc_tile_hardwall_show(struct seq_file *sf, void *v)
 661 {
 662         struct hardwall_info *r;
 663
 664         if (udn_disabled) {
 665                 seq_printf(sf, "%dx%d 0,0 pids:\n", smp_width, smp_height);
 666                 return 0;
 667         }
 668
 669         spin_lock_irq(&hardwall_lock);
 670         list_for_each_entry(r, &rectangles, list) {
 671                 struct task_struct *p;
 672                 seq_printf(sf, "%dx%d %d,%d pids:",
 673                            r->width, r->height, r->ulhc_x, r->ulhc_y);
 674                 list_for_each_entry(p, &r->task_head, thread.hardwall_list) {
 675                         unsigned int cpu = cpumask_first(&p->cpus_allowed);
 676                         unsigned int x = cpu % smp_width;
 677                         unsigned int y = cpu / smp_width;
 678                         seq_printf(sf, " %d@%d,%d", p->pid, x, y);
 679                 }
 680                 seq_printf(sf, "\n");
 681         }
 682         spin_unlock_irq(&hardwall_lock);
 683         return 0;
 684 }
 685
 686
 687 /*
 688  * Character device support via ioctl/close.
 689  */
 690
 691 static long hardwall_ioctl(struct file *file, unsigned int a, unsigned long b)
 692 {
 693         struct hardwall_info *rect = file->private_data;
 694
 695         if (_IOC_TYPE(a) != HARDWALL_IOCTL_BASE)
 696                 return -EINVAL;
 697
 698         switch (_IOC_NR(a)) {
 699         case _HARDWALL_CREATE:
 700                 if (udn_disabled)
 701                         return -ENOSYS;
 702                 if (rect != NULL)
 703                         return -EALREADY;
 704                 rect = hardwall_create(_IOC_SIZE(a),
 705                                         (const unsigned char __user *)b);
 706                 if (IS_ERR(rect))
 707                         return PTR_ERR(rect);
 708                 file->private_data = rect;
 709                 return 0;
 710
 711         case _HARDWALL_ACTIVATE:
 712                 return hardwall_activate(rect);
 713
 714         case _HARDWALL_DEACTIVATE:
 715                 if (current->thread.hardwall != rect)
 716                         return -EINVAL;
 717                 return hardwall_deactivate(current);
 718
 719         default:
 720                 return -EINVAL;
 721         }
 722 }
 723
 724 #ifdef CONFIG_COMPAT
 725 static long hardwall_compat_ioctl(struct file *file,
 726                                   unsigned int a, unsigned long b)
 727 {
 728         /* Sign-extend the argument so it can be used as a pointer. */
 729         return hardwall_ioctl(file, a, (unsigned long)compat_ptr(b));
 730 }
 731 #endif
 732
 733 /* The user process closed the file; revoke access to user networks. */
 734 static int hardwall_flush(struct file *file, fl_owner_t owner)
 735 {
 736         struct hardwall_info *rect = file->private_data;
 737         struct task_struct *task, *tmp;
 738         unsigned long flags;
 739
 740         if (rect) {
 741                 /*
 742                  * NOTE: if multiple threads are activated on this hardwall
 743                  * file, the other threads will continue having access to the
 744                  * UDN until they are context-switched out and back in again.
 745                  *
 746                  * NOTE: A NULL files pointer means the task is being torn
 747                  * down, so in that case we also deactivate it.
 748                  */
 749                 spin_lock_irqsave(&hardwall_lock, flags);
 750                 list_for_each_entry_safe(task, tmp, &rect->task_head,
 751                                          thread.hardwall_list) {
 752                         if (task->files == owner || task->files == NULL)
 753                                 _hardwall_deactivate(task);
 754                 }
 755                 spin_unlock_irqrestore(&hardwall_lock, flags);
 756         }
 757
 758         return 0;
 759 }
 760
 761 /* This hardwall is gone, so destroy it. */
 762 static int hardwall_release(struct inode *inode, struct file *file)
 763 {
 764         hardwall_destroy(file->private_data);
 765         return 0;
 766 }
 767
 768 static const struct file_operations dev_hardwall_fops = {
 769         .open           = nonseekable_open,
 770         .unlocked_ioctl = hardwall_ioctl,
 771 #ifdef CONFIG_COMPAT
 772         .compat_ioctl   = hardwall_compat_ioctl,
 773 #endif
 774         .flush          = hardwall_flush,
 775         .release        = hardwall_release,
 776 };
 777
 778 static struct cdev hardwall_dev;
 779
 780 static int __init dev_hardwall_init(void)
 781 {
 782         int rc;
 783         dev_t dev;
 784
 785         rc = alloc_chrdev_region(&dev, 0, 1, "hardwall");
 786         if (rc < 0)
 787                 return rc;
 788         cdev_init(&hardwall_dev, &dev_hardwall_fops);
 789         rc = cdev_add(&hardwall_dev, dev, 1);
 790         if (rc < 0)
 791                 return rc;
 792
 793         return 0;
 794 }
 795 late_initcall(dev_hardwall_init);