use C99 initializers in segment ops structures

          --- old/usr/src/uts/sparc/v9/vm/seg_nf.c
          +++ new/usr/src/uts/sparc/v9/vm/seg_nf.c

   1    1  /*
   2    2   * CDDL HEADER START
   3    3   *
   4    4   * The contents of this file are subject to the terms of the
   5    5   * Common Development and Distribution License (the "License").
   6    6   * You may not use this file except in compliance with the License.
   7    7   *
   8    8   * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9    9   * or http://www.opensolaris.org/os/licensing.
  10   10   * See the License for the specific language governing permissions
  11   11   * and limitations under the License.
  12   12   *
  13   13   * When distributing Covered Code, include this CDDL HEADER in each
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  /*
  22   22   * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  23   23   * Use is subject to license terms.
  24   24   */
  25   25  
  26   26  /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
  27   27  /* All Rights Reserved */
  28   28  
  29   29  /*
  30   30   * Portions of this source code were derived from Berkeley 4.3 BSD
  31   31   * under license from the Regents of the University of California.
  32   32   */
  33   33  
  34   34  /*
  35   35   * VM - segment for non-faulting loads.
  36   36   */
  37   37  
  38   38  #include <sys/types.h>
  39   39  #include <sys/t_lock.h>
  40   40  #include <sys/param.h>
  41   41  #include <sys/mman.h>
  42   42  #include <sys/errno.h>
  43   43  #include <sys/kmem.h>
  44   44  #include <sys/cmn_err.h>
  45   45  #include <sys/vnode.h>
  46   46  #include <sys/proc.h>
  47   47  #include <sys/conf.h>
  48   48  #include <sys/debug.h>
  49   49  #include <sys/archsystm.h>
  50   50  #include <sys/lgrp.h>
  51   51  
  52   52  #include <vm/page.h>
  53   53  #include <vm/hat.h>
  54   54  #include <vm/as.h>
  55   55  #include <vm/seg.h>
  56   56  #include <vm/vpage.h>
  57   57  
  58   58  /*
  59   59   * Private seg op routines.
  60   60   */
  61   61  static int      segnf_dup(struct seg *seg, struct seg *newseg);
  62   62  static int      segnf_unmap(struct seg *seg, caddr_t addr, size_t len);
  63   63  static void     segnf_free(struct seg *seg);
  64   64  static faultcode_t segnf_nomap(void);
  65   65  static int      segnf_setprot(struct seg *seg, caddr_t addr,
  66   66                      size_t len, uint_t prot);
  67   67  static int      segnf_checkprot(struct seg *seg, caddr_t addr,
  68   68                      size_t len, uint_t prot);
  69   69  static void     segnf_badop(void);
  70   70  static int      segnf_nop(void);
  71   71  static int      segnf_getprot(struct seg *seg, caddr_t addr,
  72   72                      size_t len, uint_t *protv);
  73   73  static u_offset_t segnf_getoffset(struct seg *seg, caddr_t addr);
  74   74  static int      segnf_gettype(struct seg *seg, caddr_t addr);
  75   75  static int      segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp);
  76   76  static void     segnf_dump(struct seg *seg);

  77   77  static int      segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
  78   78                      struct page ***ppp, enum lock_type type, enum seg_rw rw);
  79   79  static int      segnf_setpagesize(struct seg *seg, caddr_t addr, size_t len,
  80   80                      uint_t szc);
  81   81  static int      segnf_getmemid(struct seg *seg, caddr_t addr, memid_t *memidp);
  82   82  static lgrp_mem_policy_info_t   *segnf_getpolicy(struct seg *seg,
  83   83      caddr_t addr);
  84   84  
  85   85  
  86   86  struct seg_ops segnf_ops = {
  87      -        segnf_dup,
  88      -        segnf_unmap,
  89      -        segnf_free,
  90      -        (faultcode_t (*)(struct hat *, struct seg *, caddr_t, size_t,
  91      -            enum fault_type, enum seg_rw))
  92      -                segnf_nomap,            /* fault */
  93      -        (faultcode_t (*)(struct seg *, caddr_t))
  94      -                segnf_nomap,            /* faulta */
  95      -        segnf_setprot,
  96      -        segnf_checkprot,
  97      -        (int (*)())segnf_badop,         /* kluster */
  98      -        (int (*)(struct seg *, caddr_t, size_t, int, uint_t))
  99      -                segnf_nop,              /* sync */
 100      -        (size_t (*)(struct seg *, caddr_t, size_t, char *))
 101      -                segnf_nop,              /* incore */
 102      -        (int (*)(struct seg *, caddr_t, size_t, int, int, ulong_t *, size_t))
 103      -                segnf_nop,              /* lockop */
 104      -        segnf_getprot,
 105      -        segnf_getoffset,
 106      -        segnf_gettype,
 107      -        segnf_getvp,
 108      -        (int (*)(struct seg *, caddr_t, size_t, uint_t))
 109      -                segnf_nop,              /* advise */
 110      -        segnf_dump,
 111      -        segnf_pagelock,
 112      -        segnf_setpagesize,
 113      -        segnf_getmemid,
 114      -        segnf_getpolicy,
       87 +        .dup            = segnf_dup,
       88 +        .unmap          = segnf_unmap,
       89 +        .free           = segnf_free,
       90 +        .fault          = (faultcode_t (*)(struct hat *, struct seg *, caddr_t,
       91 +            size_t, enum fault_type, enum seg_rw))segnf_nomap,
       92 +        .faulta         = (faultcode_t (*)(struct seg *, caddr_t)) segnf_nomap,
       93 +        .setprot        = segnf_setprot,
       94 +        .checkprot      = segnf_checkprot,
       95 +        .kluster        = (int (*)())segnf_badop,
       96 +        .sync           = (int (*)(struct seg *, caddr_t, size_t, int, uint_t))
       97 +                segnf_nop,
       98 +        .incore         = (size_t (*)(struct seg *, caddr_t, size_t, char *))
       99 +                segnf_nop,
      100 +        .lockop         = (int (*)(struct seg *, caddr_t, size_t, int, int,
      101 +            ulong_t *, size_t))segnf_nop,
      102 +        .getprot        = segnf_getprot,
      103 +        .getoffset      = segnf_getoffset,
      104 +        .gettype        = segnf_gettype,
      105 +        .getvp          = segnf_getvp,
      106 +        .advise         = (int (*)(struct seg *, caddr_t, size_t, uint_t))
      107 +                segnf_nop,
      108 +        .dump           = segnf_dump,
      109 +        .pagelock       = segnf_pagelock,
      110 +        .setpagesize    = segnf_setpagesize,
      111 +        .getmemid       = segnf_getmemid,
      112 +        .getpolicy      = segnf_getpolicy,
 115  113  };
 116  114  
 117  115  /*
 118  116   * vnode and page for the page of zeros we use for the nf mappings.
 119  117   */
 120  118  static kmutex_t segnf_lock;
 121  119  static struct vnode nfvp;
 122  120  static struct page **nfpp;
 123  121  
 124  122  #define addr_to_vcolor(addr)                                            \

 125  123          (shm_alignment) ?                                               \
 126  124          ((int)(((uintptr_t)(addr) & (shm_alignment - 1)) >> PAGESHIFT)) : 0
 127  125  
 128  126  /*
 129  127   * We try to limit the number of Non-fault segments created.
 130  128   * Non fault segments are created to optimize sparc V9 code which uses
 131  129   * the sparc nonfaulting load ASI (ASI_PRIMARY_NOFAULT).
 132  130   *
 133  131   * There are several reasons why creating too many non-fault segments
 134  132   * could cause problems.
 135  133   *
 136  134   *      First, excessive allocation of kernel resources for the seg
 137  135   *      structures and the HAT data to map the zero pages.
 138  136   *
 139  137   *      Secondly, creating nofault segments actually uses up user virtual
 140  138   *      address space. This makes it unavailable for subsequent mmap(0, ...)
 141  139   *      calls which use as_gap() to find empty va regions.  Creation of too
 142  140   *      many nofault segments could thus interfere with the ability of the
 143  141   *      runtime linker to load a shared object.
 144  142   */
 145  143  #define MAXSEGFORNF     (10000)
 146  144  #define MAXNFSEARCH     (5)
 147  145  
 148  146  
 149  147  /*
 150  148   * Must be called from startup()
 151  149   */
 152  150  void
 153  151  segnf_init()
 154  152  {
 155  153          mutex_init(&segnf_lock, NULL, MUTEX_DEFAULT, NULL);
 156  154  }
 157  155  
 158  156  
 159  157  /*
 160  158   * Create a no-fault segment.
 161  159   *
 162  160   * The no-fault segment is not technically necessary, as the code in
 163  161   * nfload() in trap.c will emulate the SPARC instruction and load
 164  162   * a value of zero in the destination register.
 165  163   *
 166  164   * However, this code tries to put a page of zero's at the nofault address
 167  165   * so that subsequent non-faulting loads to the same page will not
 168  166   * trap with a tlb miss.
 169  167   *
 170  168   * In order to help limit the number of segments we merge adjacent nofault
 171  169   * segments into a single segment.  If we get a large number of segments
 172  170   * we'll also try to delete a random other nf segment.
 173  171   */
 174  172  /* ARGSUSED */
 175  173  int
 176  174  segnf_create(struct seg *seg, void *argsp)
 177  175  {
 178  176          uint_t prot;
 179  177          pgcnt_t vacpgs;
 180  178          u_offset_t off = 0;
 181  179          caddr_t vaddr = NULL;
 182  180          int i, color;
 183  181          struct seg *s1;
 184  182          struct seg *s2;
 185  183          size_t size;
 186  184          struct as *as = seg->s_as;
 187  185  
 188  186          ASSERT(as && AS_WRITE_HELD(as, &as->a_lock));
 189  187  
 190  188          /*
 191  189           * Need a page per virtual color or just 1 if no vac.
 192  190           */
 193  191          mutex_enter(&segnf_lock);
 194  192          if (nfpp == NULL) {
 195  193                  struct seg kseg;
 196  194  
 197  195                  vacpgs = 1;
 198  196                  if (shm_alignment > PAGESIZE) {
 199  197                          vacpgs = shm_alignment >> PAGESHIFT;
 200  198                  }
 201  199  
 202  200                  nfpp = kmem_alloc(sizeof (*nfpp) * vacpgs, KM_SLEEP);
 203  201  
 204  202                  kseg.s_as = &kas;
 205  203                  for (i = 0; i < vacpgs; i++, off += PAGESIZE,
 206  204                      vaddr += PAGESIZE) {
 207  205                          nfpp[i] = page_create_va(&nfvp, off, PAGESIZE,
 208  206                              PG_WAIT | PG_NORELOC, &kseg, vaddr);
 209  207                          page_io_unlock(nfpp[i]);
 210  208                          page_downgrade(nfpp[i]);
 211  209                          pagezero(nfpp[i], 0, PAGESIZE);
 212  210                  }
 213  211          }
 214  212          mutex_exit(&segnf_lock);
 215  213  
 216  214          hat_map(as->a_hat, seg->s_base, seg->s_size, HAT_MAP);
 217  215  
 218  216          /*
 219  217           * s_data can't be NULL because of ASSERTS in the common vm code.
 220  218           */
 221  219          seg->s_ops = &segnf_ops;
 222  220          seg->s_data = seg;
 223  221          seg->s_flags |= S_PURGE;
 224  222  
 225  223          mutex_enter(&as->a_contents);
 226  224          as->a_flags |= AS_NEEDSPURGE;
 227  225          mutex_exit(&as->a_contents);
 228  226  
 229  227          prot = PROT_READ;
 230  228          color = addr_to_vcolor(seg->s_base);
 231  229          if (as != &kas)
 232  230                  prot |= PROT_USER;
 233  231          hat_memload(as->a_hat, seg->s_base, nfpp[color],
 234  232              prot | HAT_NOFAULT, HAT_LOAD);
 235  233  
 236  234          /*
 237  235           * At this point see if we can concatenate a segment to
 238  236           * a non-fault segment immediately before and/or after it.
 239  237           */
 240  238          if ((s1 = AS_SEGPREV(as, seg)) != NULL &&
 241  239              s1->s_ops == &segnf_ops &&
 242  240              s1->s_base + s1->s_size == seg->s_base) {
 243  241                  size = s1->s_size;
 244  242                  seg_free(s1);
 245  243                  seg->s_base -= size;
 246  244                  seg->s_size += size;
 247  245          }
 248  246  
 249  247          if ((s2 = AS_SEGNEXT(as, seg)) != NULL &&
 250  248              s2->s_ops == &segnf_ops &&
 251  249              seg->s_base + seg->s_size == s2->s_base) {
 252  250                  size = s2->s_size;
 253  251                  seg_free(s2);
 254  252                  seg->s_size += size;
 255  253          }
 256  254  
 257  255          /*
 258  256           * if we already have a lot of segments, try to delete some other
 259  257           * nofault segment to reduce the probability of uncontrolled segment
 260  258           * creation.
 261  259           *
 262  260           * the code looks around quickly (no more than MAXNFSEARCH segments
 263  261           * each way) for another NF segment and then deletes it.
 264  262           */
 265  263          if (avl_numnodes(&as->a_segtree) > MAXSEGFORNF) {
 266  264                  size = 0;
 267  265                  s2 = NULL;
 268  266                  s1 = AS_SEGPREV(as, seg);
 269  267                  while (size++ < MAXNFSEARCH && s1 != NULL) {
 270  268                          if (s1->s_ops == &segnf_ops)
 271  269                                  s2 = s1;
 272  270                          s1 = AS_SEGPREV(s1->s_as, seg);
 273  271                  }
 274  272                  if (s2 == NULL) {
 275  273                          s1 = AS_SEGNEXT(as, seg);
 276  274                          while (size-- > 0 && s1 != NULL) {
 277  275                                  if (s1->s_ops == &segnf_ops)
 278  276                                          s2 = s1;
 279  277                                  s1 = AS_SEGNEXT(as, seg);
 280  278                          }
 281  279                  }
 282  280                  if (s2 != NULL)
 283  281                          seg_unmap(s2);
 284  282          }
 285  283  
 286  284          return (0);
 287  285  }
 288  286  
 289  287  /*
 290  288   * Never really need "No fault" segments, so they aren't dup'd.
 291  289   */
 292  290  /* ARGSUSED */
 293  291  static int
 294  292  segnf_dup(struct seg *seg, struct seg *newseg)
 295  293  {
 296  294          panic("segnf_dup");
 297  295          return (0);
 298  296  }
 299  297  
 300  298  /*
 301  299   * Split a segment at addr for length len.
 302  300   */
 303  301  static int
 304  302  segnf_unmap(struct seg *seg, caddr_t addr, size_t len)
 305  303  {
 306  304          ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as, &seg->s_as->a_lock));
 307  305  
 308  306          /*
 309  307           * Check for bad sizes.
 310  308           */
 311  309          if (addr < seg->s_base || addr + len > seg->s_base + seg->s_size ||
 312  310              (len & PAGEOFFSET) || ((uintptr_t)addr & PAGEOFFSET)) {
 313  311                  cmn_err(CE_PANIC, "segnf_unmap: bad unmap size");
 314  312          }
 315  313  
 316  314          /*
 317  315           * Unload any hardware translations in the range to be taken out.
 318  316           */
 319  317          hat_unload(seg->s_as->a_hat, addr, len, HAT_UNLOAD_UNMAP);
 320  318  
 321  319          if (addr == seg->s_base && len == seg->s_size) {
 322  320                  /*
 323  321                   * Freeing entire segment.
 324  322                   */
 325  323                  seg_free(seg);
 326  324          } else if (addr == seg->s_base) {
 327  325                  /*
 328  326                   * Freeing the beginning of the segment.
 329  327                   */
 330  328                  seg->s_base += len;
 331  329                  seg->s_size -= len;
 332  330          } else if (addr + len == seg->s_base + seg->s_size) {
 333  331                  /*
 334  332                   * Freeing the end of the segment.
 335  333                   */
 336  334                  seg->s_size -= len;
 337  335          } else {
 338  336                  /*
 339  337                   * The section to go is in the middle of the segment, so we
 340  338                   * have to cut it into two segments.  We shrink the existing
 341  339                   * "seg" at the low end, and create "nseg" for the high end.
 342  340                   */
 343  341                  caddr_t nbase = addr + len;
 344  342                  size_t nsize = (seg->s_base + seg->s_size) - nbase;
 345  343                  struct seg *nseg;
 346  344  
 347  345                  /*
 348  346                   * Trim down "seg" before trying to stick "nseg" into the as.
 349  347                   */
 350  348                  seg->s_size = addr - seg->s_base;
 351  349                  nseg = seg_alloc(seg->s_as, nbase, nsize);
 352  350                  if (nseg == NULL)
 353  351                          cmn_err(CE_PANIC, "segnf_unmap: seg_alloc failed");
 354  352  
 355  353                  /*
 356  354                   * s_data can't be NULL because of ASSERTs in common VM code.
 357  355                   */
 358  356                  nseg->s_ops = seg->s_ops;
 359  357                  nseg->s_data = nseg;
 360  358                  nseg->s_flags |= S_PURGE;
 361  359                  mutex_enter(&seg->s_as->a_contents);
 362  360                  seg->s_as->a_flags |= AS_NEEDSPURGE;
 363  361                  mutex_exit(&seg->s_as->a_contents);
 364  362          }
 365  363  
 366  364          return (0);
 367  365  }
 368  366  
 369  367  /*
 370  368   * Free a segment.
 371  369   */
 372  370  static void
 373  371  segnf_free(struct seg *seg)
 374  372  {
 375  373          ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as, &seg->s_as->a_lock));
 376  374  }
 377  375  
 378  376  /*
 379  377   * No faults allowed on segnf.
 380  378   */
 381  379  static faultcode_t
 382  380  segnf_nomap(void)
 383  381  {
 384  382          return (FC_NOMAP);
 385  383  }
 386  384  
 387  385  /* ARGSUSED */
 388  386  static int
 389  387  segnf_setprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
 390  388  {
 391  389          ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 392  390          return (EACCES);
 393  391  }
 394  392  
 395  393  /* ARGSUSED */
 396  394  static int
 397  395  segnf_checkprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
 398  396  {
 399  397          uint_t sprot;
 400  398          ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 401  399  
 402  400          sprot = seg->s_as == &kas ?  PROT_READ : PROT_READ|PROT_USER;
 403  401          return ((prot & sprot) == prot ? 0 : EACCES);
 404  402  }
 405  403  
 406  404  static void
 407  405  segnf_badop(void)
 408  406  {
 409  407          panic("segnf_badop");
 410  408          /*NOTREACHED*/
 411  409  }
 412  410  
 413  411  static int
 414  412  segnf_nop(void)
 415  413  {
 416  414          return (0);
 417  415  }
 418  416  
 419  417  static int
 420  418  segnf_getprot(struct seg *seg, caddr_t addr, size_t len, uint_t *protv)
 421  419  {
 422  420          size_t pgno = seg_page(seg, addr + len) - seg_page(seg, addr) + 1;
 423  421          size_t p;
 424  422          ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 425  423  
 426  424          for (p = 0; p < pgno; ++p)
 427  425                  protv[p] = PROT_READ;
 428  426          return (0);
 429  427  }
 430  428  
 431  429  /* ARGSUSED */
 432  430  static u_offset_t
 433  431  segnf_getoffset(struct seg *seg, caddr_t addr)
 434  432  {
 435  433          ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 436  434  
 437  435          return ((u_offset_t)0);
 438  436  }
 439  437  
 440  438  /* ARGSUSED */
 441  439  static int
 442  440  segnf_gettype(struct seg *seg, caddr_t addr)
 443  441  {
 444  442          ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 445  443  
 446  444          return (MAP_SHARED);
 447  445  }
 448  446  
 449  447  /* ARGSUSED */
 450  448  static int
 451  449  segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
 452  450  {
 453  451          ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 454  452  
 455  453          *vpp = &nfvp;
 456  454          return (0);
 457  455  }
 458  456  
 459  457  /*
 460  458   * segnf pages are not dumped, so we just return
 461  459   */
 462  460  /* ARGSUSED */
 463  461  static void
 464  462  segnf_dump(struct seg *seg)
 465  463  {}
 466  464  
 467  465  /*ARGSUSED*/
 468  466  static int
 469  467  segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
 470  468      struct page ***ppp, enum lock_type type, enum seg_rw rw)
 471  469  {
 472  470          return (ENOTSUP);
 473  471  }
 474  472  
 475  473  /*ARGSUSED*/
 476  474  static int
 477  475  segnf_setpagesize(struct seg *seg, caddr_t addr, size_t len,
 478  476      uint_t szc)
 479  477  {
 480  478          return (ENOTSUP);
 481  479  }
 482  480  
 483  481  /*ARGSUSED*/
 484  482  static int
 485  483  segnf_getmemid(struct seg *seg, caddr_t addr, memid_t *memidp)
 486  484  {
 487  485          return (ENODEV);
 488  486  }
 489  487  
 490  488  /*ARGSUSED*/
 491  489  static lgrp_mem_policy_info_t *
 492  490  segnf_getpolicy(struct seg *seg, caddr_t addr)
 493  491  {
 494  492          return (NULL);
 495  493  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX