Print this page
patch as-lock-macro-simplification

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/fs/proc/prvnops.c
          +++ new/usr/src/uts/common/fs/proc/prvnops.c
↓ open down ↓ 881 lines elided ↑ open up ↑
 882  882                  return (error);
 883  883  
 884  884          p = pnp->pr_common->prc_proc;
 885  885          as = p->p_as;
 886  886  
 887  887          if ((p->p_flag & SSYS) || as == &kas) {
 888  888                  prunlock(pnp);
 889  889                  return (0);
 890  890          }
 891  891  
 892      -        if (!AS_LOCK_TRYENTER(as, &as->a_lock, RW_WRITER)) {
      892 +        if (!AS_LOCK_TRYENTER(as, RW_WRITER)) {
 893  893                  prunlock(pnp);
 894  894                  delay(1);
 895  895                  goto readmap_common;
 896  896          }
 897  897          mutex_exit(&p->p_lock);
 898  898  
 899  899          switch (type) {
 900  900          case PR_XMAP:
 901  901                  error = prgetxmap(p, &iolhead);
 902  902                  break;
 903  903          case PR_RMAP:
 904  904                  error = prgetmap(p, 1, &iolhead);
 905  905                  break;
 906  906          case PR_MAP:
 907  907                  error = prgetmap(p, 0, &iolhead);
 908  908                  break;
 909  909          }
 910  910  
 911      -        AS_LOCK_EXIT(as, &as->a_lock);
      911 +        AS_LOCK_EXIT(as);
 912  912          mutex_enter(&p->p_lock);
 913  913          prunlock(pnp);
 914  914  
 915  915          error = pr_iol_uiomove_and_free(&iolhead, uiop, error);
 916  916  
 917  917          return (error);
 918  918  }
 919  919  
 920  920  static int
 921  921  pr_read_map(prnode_t *pnp, uio_t *uiop)
↓ open down ↓ 1076 lines elided ↑ open up ↑
1998 1998          if ((p->p_flag & SSYS) || as == &kas) {
1999 1999                  prunlock(pnp);
2000 2000                  return (0);
2001 2001          }
2002 2002  
2003 2003          if (PROCESS_NOT_32BIT(p)) {
2004 2004                  prunlock(pnp);
2005 2005                  return (EOVERFLOW);
2006 2006          }
2007 2007  
2008      -        if (!AS_LOCK_TRYENTER(as, &as->a_lock, RW_WRITER)) {
     2008 +        if (!AS_LOCK_TRYENTER(as, RW_WRITER)) {
2009 2009                  prunlock(pnp);
2010 2010                  delay(1);
2011 2011                  goto readmap32_common;
2012 2012          }
2013 2013          mutex_exit(&p->p_lock);
2014 2014  
2015 2015          switch (type) {
2016 2016          case PR_XMAP:
2017 2017                  error = prgetxmap32(p, &iolhead);
2018 2018                  break;
2019 2019          case PR_RMAP:
2020 2020                  error = prgetmap32(p, 1, &iolhead);
2021 2021                  break;
2022 2022          case PR_MAP:
2023 2023                  error = prgetmap32(p, 0, &iolhead);
2024 2024                  break;
2025 2025          }
2026      -        AS_LOCK_EXIT(as, &as->a_lock);
     2026 +        AS_LOCK_EXIT(as);
2027 2027          mutex_enter(&p->p_lock);
2028 2028          prunlock(pnp);
2029 2029  
2030 2030          error = pr_iol_uiomove_and_free(&iolhead, uiop, error);
2031 2031  
2032 2032          return (error);
2033 2033  }
2034 2034  
2035 2035  static int
2036 2036  pr_read_map_32(prnode_t *pnp, uio_t *uiop)
↓ open down ↓ 886 lines elided ↑ open up ↑
2923 2923          case PR_PIDDIR:
2924 2924                  /* va_nlink: count 'lwp', 'object' and 'fd' directory links */
2925 2925                  vap->va_nlink = 5;
2926 2926                  vap->va_size = sizeof (piddir);
2927 2927                  break;
2928 2928          case PR_OBJECTDIR:
2929 2929                  if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
2930 2930                          vap->va_size = 2 * PRSDSIZE;
2931 2931                  else {
2932 2932                          mutex_exit(&p->p_lock);
2933      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     2933 +                        AS_LOCK_ENTER(as, RW_WRITER);
2934 2934                          if (as->a_updatedir)
2935 2935                                  rebuild_objdir(as);
2936 2936                          vap->va_size = (as->a_sizedir + 2) * PRSDSIZE;
2937      -                        AS_LOCK_EXIT(as, &as->a_lock);
     2937 +                        AS_LOCK_EXIT(as);
2938 2938                          mutex_enter(&p->p_lock);
2939 2939                  }
2940 2940                  vap->va_nlink = 2;
2941 2941                  break;
2942 2942          case PR_PATHDIR:
2943 2943                  if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
2944 2944                          vap->va_size = (P_FINFO(p)->fi_nfiles + 4) * PRSDSIZE;
2945 2945                  else {
2946 2946                          mutex_exit(&p->p_lock);
2947      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     2947 +                        AS_LOCK_ENTER(as, RW_WRITER);
2948 2948                          if (as->a_updatedir)
2949 2949                                  rebuild_objdir(as);
2950 2950                          vap->va_size = (as->a_sizedir + 4 +
2951 2951                              P_FINFO(p)->fi_nfiles) * PRSDSIZE;
2952      -                        AS_LOCK_EXIT(as, &as->a_lock);
     2952 +                        AS_LOCK_EXIT(as);
2953 2953                          mutex_enter(&p->p_lock);
2954 2954                  }
2955 2955                  vap->va_nlink = 2;
2956 2956                  break;
2957 2957          case PR_PATH:
2958 2958          case PR_CURDIR:
2959 2959          case PR_ROOTDIR:
2960 2960          case PR_CT:
2961 2961                  vap->va_type = VLNK;
2962 2962                  vap->va_size = 0;
↓ open down ↓ 45 lines elided ↑ open up ↑
3008 3008                      (p->p_lwpcnt + p->p_zombcnt) *
3009 3009                      PR_OBJSPAN(lwpsinfo32_t, lwpsinfo_t);
3010 3010                  break;
3011 3011          case PR_MAP:
3012 3012          case PR_RMAP:
3013 3013          case PR_XMAP:
3014 3014                  if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
3015 3015                          vap->va_size = 0;
3016 3016                  else {
3017 3017                          mutex_exit(&p->p_lock);
3018      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     3018 +                        AS_LOCK_ENTER(as, RW_WRITER);
3019 3019                          if (type == PR_MAP)
3020 3020                                  vap->va_mtime = as->a_updatetime;
3021 3021                          if (type == PR_XMAP)
3022 3022                                  vap->va_size = prnsegs(as, 0) *
3023 3023                                      PR_OBJSIZE(prxmap32_t, prxmap_t);
3024 3024                          else
3025 3025                                  vap->va_size = prnsegs(as, type == PR_RMAP) *
3026 3026                                      PR_OBJSIZE(prmap32_t, prmap_t);
3027      -                        AS_LOCK_EXIT(as, &as->a_lock);
     3027 +                        AS_LOCK_EXIT(as);
3028 3028                          mutex_enter(&p->p_lock);
3029 3029                  }
3030 3030                  break;
3031 3031          case PR_CRED:
3032 3032                  mutex_enter(&p->p_crlock);
3033 3033                  vap->va_size = sizeof (prcred_t);
3034 3034                  ngroups = crgetngroups(p->p_cred);
3035 3035                  if (ngroups > 1)
3036 3036                          vap->va_size += (ngroups - 1) * sizeof (gid_t);
3037 3037                  mutex_exit(&p->p_crlock);
↓ open down ↓ 28 lines elided ↑ open up ↑
3066 3066          case PR_PAGEDATA:
3067 3067                  if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
3068 3068                          vap->va_size = 0;
3069 3069                  else {
3070 3070                          /*
3071 3071                           * We can drop p->p_lock before grabbing the
3072 3072                           * address space lock because p->p_as will not
3073 3073                           * change while the process is marked P_PR_LOCK.
3074 3074                           */
3075 3075                          mutex_exit(&p->p_lock);
3076      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     3076 +                        AS_LOCK_ENTER(as, RW_WRITER);
3077 3077  #ifdef _LP64
3078 3078                          vap->va_size = iam32bit?
3079 3079                              prpdsize32(as) : prpdsize(as);
3080 3080  #else
3081 3081                          vap->va_size = prpdsize(as);
3082 3082  #endif
3083      -                        AS_LOCK_EXIT(as, &as->a_lock);
     3083 +                        AS_LOCK_EXIT(as);
3084 3084                          mutex_enter(&p->p_lock);
3085 3085                  }
3086 3086                  break;
3087 3087          case PR_OPAGEDATA:
3088 3088                  if ((p->p_flag & SSYS) || (as = p->p_as) == &kas)
3089 3089                          vap->va_size = 0;
3090 3090                  else {
3091 3091                          mutex_exit(&p->p_lock);
3092      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     3092 +                        AS_LOCK_ENTER(as, RW_WRITER);
3093 3093  #ifdef _LP64
3094 3094                          vap->va_size = iam32bit?
3095 3095                              oprpdsize32(as) : oprpdsize(as);
3096 3096  #else
3097 3097                          vap->va_size = oprpdsize(as);
3098 3098  #endif
3099      -                        AS_LOCK_EXIT(as, &as->a_lock);
     3099 +                        AS_LOCK_EXIT(as);
3100 3100                          mutex_enter(&p->p_lock);
3101 3101                  }
3102 3102                  break;
3103 3103          case PR_WATCH:
3104 3104                  vap->va_size = avl_numnodes(&p->p_warea) *
3105 3105                      PR_OBJSIZE(prwatch32_t, prwatch_t);
3106 3106                  break;
3107 3107          case PR_LWPSTATUS:
3108 3108                  vap->va_size = PR_OBJSIZE(lwpstatus32_t, lwpstatus_t);
3109 3109                  break;
↓ open down ↓ 576 lines elided ↑ open up ↑
3686 3686                  return (NULL);
3687 3687          }
3688 3688  
3689 3689          /*
3690 3690           * We drop p_lock before grabbing the address space lock
3691 3691           * in order to avoid a deadlock with the clock thread.
3692 3692           * The process will not disappear and its address space
3693 3693           * will not change because it is marked P_PR_LOCK.
3694 3694           */
3695 3695          mutex_exit(&p->p_lock);
3696      -        AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
     3696 +        AS_LOCK_ENTER(as, RW_READER);
3697 3697          if ((seg = AS_SEGFIRST(as)) == NULL) {
3698 3698                  vp = NULL;
3699 3699                  goto out;
3700 3700          }
3701 3701          if (strcmp(comp, "a.out") == 0) {
3702 3702                  vp = p->p_exec;
3703 3703                  goto out;
3704 3704          }
3705 3705          do {
3706 3706                  /*
↓ open down ↓ 12 lines elided ↑ open up ↑
3719 3719                          if (strcmp(name, comp) == 0)
3720 3720                                  goto out;
3721 3721                  }
3722 3722          } while ((seg = AS_SEGNEXT(as, seg)) != NULL);
3723 3723  
3724 3724          vp = NULL;
3725 3725  out:
3726 3726          if (vp != NULL) {
3727 3727                  VN_HOLD(vp);
3728 3728          }
3729      -        AS_LOCK_EXIT(as, &as->a_lock);
     3729 +        AS_LOCK_EXIT(as);
3730 3730          mutex_enter(&p->p_lock);
3731 3731          prunlock(dpnp);
3732 3732  
3733 3733          if (vp == NULL)
3734 3734                  prfreenode(pnp);
3735 3735          else {
3736 3736                  /*
3737 3737                   * Fill in the prnode so future references will
3738 3738                   * be able to find the underlying object's vnode.
3739 3739                   * Don't link this prnode into the list of all
↓ open down ↓ 403 lines elided ↑ open up ↑
4143 4143                                  vp = p->p_execdir;
4144 4144                                  VN_HOLD(vp);
4145 4145                                  type = NAME_OBJECT;
4146 4146                                  flags |= PR_AOUT;
4147 4147                          } else {
4148 4148                                  vp = p->p_exec;
4149 4149                                  VN_HOLD(vp);
4150 4150                                  type = NAME_OBJECT;
4151 4151                          }
4152 4152                  } else {
4153      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
     4153 +                        AS_LOCK_ENTER(as, RW_READER);
4154 4154                          if ((seg = AS_SEGFIRST(as)) != NULL) {
4155 4155                                  do {
4156 4156                                          /*
4157 4157                                           * Manufacture a filename for the
4158 4158                                           * "object" directory.
4159 4159                                           */
4160 4160                                          vattr.va_mask = AT_FSID|AT_NODEID;
4161 4161                                          if (seg->s_ops == &segvn_ops &&
4162 4162                                              SEGOP_GETVP(seg, seg->s_base, &vp)
4163 4163                                              == 0 &&
↓ open down ↓ 13 lines elided ↑ open up ↑
4177 4177                                  } while ((seg = AS_SEGNEXT(as, seg)) != NULL);
4178 4178                          }
4179 4179  
4180 4180                          if (seg == NULL) {
4181 4181                                  vp = NULL;
4182 4182                          } else {
4183 4183                                  VN_HOLD(vp);
4184 4184                                  type = NAME_OBJECT;
4185 4185                          }
4186 4186  
4187      -                        AS_LOCK_EXIT(as, &as->a_lock);
     4187 +                        AS_LOCK_EXIT(as);
4188 4188                  }
4189 4189          }
4190 4190  
4191 4191  
4192 4192          switch (type) {
4193 4193          case NAME_FD:
4194 4194                  mutex_enter(&fip->fi_lock);
4195 4195                  if (fd < fip->fi_nfiles) {
4196 4196                          UF_ENTER(ufp, fip, fd);
4197 4197                          if (ufp->uf_file != NULL) {
↓ open down ↓ 633 lines elided ↑ open up ↑
4831 4831  {
4832 4832          struct seg *seg;
4833 4833          vnode_t *vp;
4834 4834          vattr_t vattr;
4835 4835          vnode_t **dir;
4836 4836          ulong_t nalloc;
4837 4837          ulong_t nentries;
4838 4838          int i, j;
4839 4839          ulong_t nold, nnew;
4840 4840  
4841      -        ASSERT(AS_WRITE_HELD(as, &as->a_lock));
     4841 +        ASSERT(AS_WRITE_HELD(as));
4842 4842  
4843 4843          if (as->a_updatedir == 0 && as->a_objectdir != NULL)
4844 4844                  return;
4845 4845          as->a_updatedir = 0;
4846 4846  
4847 4847          if ((nalloc = avl_numnodes(&as->a_segtree)) == 0 ||
4848 4848              (seg = AS_SEGFIRST(as)) == NULL)    /* can't happen? */
4849 4849                  return;
4850 4850  
4851 4851          /*
↓ open down ↓ 84 lines elided ↑ open up ↑
4936 4936  }
4937 4937  
4938 4938  /*
4939 4939   * Return the vnode from a slot in the process's object directory.
4940 4940   * The caller must have locked the process's address space.
4941 4941   * The only caller is below, in pr_readdir_objectdir().
4942 4942   */
4943 4943  static vnode_t *
4944 4944  obj_entry(struct as *as, int slot)
4945 4945  {
4946      -        ASSERT(AS_LOCK_HELD(as, &as->a_lock));
     4946 +        ASSERT(AS_LOCK_HELD(as));
4947 4947          if (as->a_objectdir == NULL)
4948 4948                  return (NULL);
4949 4949          ASSERT(slot < as->a_sizedir);
4950 4950          return (as->a_objectdir[slot]);
4951 4951  }
4952 4952  
4953 4953  /* ARGSUSED */
4954 4954  static int
4955 4955  pr_readdir_objectdir(prnode_t *pnp, uio_t *uiop, int *eofp)
4956 4956  {
↓ open down ↓ 43 lines elided ↑ open up ↑
5000 5000          while ((error = gfs_readdir_pred(&gstate, uiop, &n)) == 0) {
5001 5001                  vattr_t vattr;
5002 5002                  char str[64];
5003 5003  
5004 5004                  /*
5005 5005                   * Set the correct size of the directory just
5006 5006                   * in case the process has changed it's address
5007 5007                   * space via mmap/munmap calls.
5008 5008                   */
5009 5009                  if (as != NULL) {
5010      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     5010 +                        AS_LOCK_ENTER(as, RW_WRITER);
5011 5011                          if (as->a_updatedir)
5012 5012                                  rebuild_objdir(as);
5013 5013                          objdirsize = as->a_sizedir;
5014 5014                  }
5015 5015  
5016 5016                  /*
5017 5017                   * Find next object.
5018 5018                   */
5019 5019                  vattr.va_mask = AT_FSID | AT_NODEID;
5020 5020                  while (n < objdirsize && (((vp = obj_entry(as, n)) == NULL) ||
5021 5021                      (VOP_GETATTR(vp, &vattr, 0, CRED(), NULL)
5022 5022                      != 0))) {
5023 5023                          vattr.va_mask = AT_FSID | AT_NODEID;
5024 5024                          n++;
5025 5025                  }
5026 5026  
5027 5027                  if (as != NULL)
5028      -                        AS_LOCK_EXIT(as, &as->a_lock);
     5028 +                        AS_LOCK_EXIT(as);
5029 5029  
5030 5030                  /*
5031 5031                   * Stop when all objects have been reported.
5032 5032                   */
5033 5033                  if (n >= objdirsize) {
5034 5034                          eof = 1;
5035 5035                          break;
5036 5036                  }
5037 5037  
5038 5038                  if (vp == p->p_exec)
↓ open down ↓ 253 lines elided ↑ open up ↑
5292 5292                  return (error);
5293 5293          p = pnp->pr_common->prc_proc;
5294 5294          fip = P_FINFO(p);
5295 5295          pslot = p->p_slot;
5296 5296          mutex_exit(&p->p_lock);
5297 5297  
5298 5298          if ((p->p_flag & SSYS) || (as = p->p_as) == &kas) {
5299 5299                  as = NULL;
5300 5300                  objdirsize = 0;
5301 5301          } else {
5302      -                AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     5302 +                AS_LOCK_ENTER(as, RW_WRITER);
5303 5303                  if (as->a_updatedir)
5304 5304                          rebuild_objdir(as);
5305 5305                  objdirsize = as->a_sizedir;
5306      -                AS_LOCK_EXIT(as, &as->a_lock);
     5306 +                AS_LOCK_EXIT(as);
5307 5307                  as = NULL;
5308 5308          }
5309 5309  
5310 5310          mutex_enter(&fip->fi_lock);
5311 5311          if ((p->p_flag & SSYS) || p->p_as == &kas)
5312 5312                  fddirsize = 0;
5313 5313          else
5314 5314                  fddirsize = fip->fi_nfiles;
5315 5315  
5316 5316          for (; uiop->uio_resid > 0; uiop->uio_offset = off + PRSDSIZE) {
↓ open down ↓ 39 lines elided ↑ open up ↑
5356 5356                          }
5357 5357  
5358 5358                          /*
5359 5359                           * We drop p_lock before grabbing the address space lock
5360 5360                           * in order to avoid a deadlock with the clock thread.
5361 5361                           * The process will not disappear and its address space
5362 5362                           * will not change because it is marked P_PR_LOCK.
5363 5363                           */
5364 5364                          if (as == NULL) {
5365 5365                                  as = p->p_as;
5366      -                                AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     5366 +                                AS_LOCK_ENTER(as, RW_WRITER);
5367 5367                          }
5368 5368  
5369 5369                          if (as->a_updatedir) {
5370 5370                                  rebuild_objdir(as);
5371 5371                                  objdirsize = as->a_sizedir;
5372 5372                          }
5373 5373  
5374 5374                          obj = idx - 4 - fddirsize;
5375 5375                          if ((vp = obj_entry(as, obj)) == NULL)
5376 5376                                  continue;
↓ open down ↓ 17 lines elided ↑ open up ↑
5394 5394                           * Error if no entries have been returned yet.
5395 5395                           */
5396 5396                          if (uiop->uio_resid == oresid)
5397 5397                                  error = EINVAL;
5398 5398                          break;
5399 5399                  }
5400 5400                  /*
5401 5401                   * Drop the address space lock to do the uiomove().
5402 5402                   */
5403 5403                  if (as != NULL)
5404      -                        AS_LOCK_EXIT(as, &as->a_lock);
     5404 +                        AS_LOCK_EXIT(as);
5405 5405  
5406 5406                  error = uiomove((caddr_t)dirent, reclen, UIO_READ, uiop);
5407 5407                  if (as != NULL)
5408      -                        AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
     5408 +                        AS_LOCK_ENTER(as, RW_WRITER);
5409 5409  
5410 5410                  if (error)
5411 5411                          break;
5412 5412          }
5413 5413  
5414 5414          if (error == 0 && eofp)
5415 5415                  *eofp = (uiop->uio_offset >= (fddirsize + 2) * PRSDSIZE);
5416 5416  
5417 5417          if (fip != NULL)
5418 5418                  mutex_exit(&fip->fi_lock);
5419 5419          if (as != NULL)
5420      -                AS_LOCK_EXIT(as, &as->a_lock);
     5420 +                AS_LOCK_EXIT(as);
5421 5421          mutex_enter(&p->p_lock);
5422 5422          prunlock(pnp);
5423 5423          return (error);
5424 5424  }
5425 5425  
5426 5426  static int
5427 5427  pr_readdir_tmpldir(prnode_t *pnp, uio_t *uiop, int *eofp)
5428 5428  {
5429 5429          proc_t *p;
5430 5430          int pslot, tslot;
↓ open down ↓ 629 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX