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