Print this page 
5045 use atomic_{inc,dec}_* instead of atomic_add_*
Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/fs/vnode.c
          +++ new/usr/src/uts/common/fs/vnode.c
↓ open down ↓ 1236 lines elided ↑ open up ↑ 
1237 1237   * use these functions.
1238 1238   */
1239 1239  void
1240 1240  vn_open_upgrade(
1241 1241          vnode_t *vp,
1242 1242          int filemode)
1243 1243  {
1244 1244          ASSERT(vp->v_type == VREG);
1245 1245  
1246 1246          if (filemode & FREAD)
1247      -                atomic_add_32(&(vp->v_rdcnt), 1);
     1247 +                atomic_inc_32(&vp->v_rdcnt);
1248 1248          if (filemode & FWRITE)
1249      -                atomic_add_32(&(vp->v_wrcnt), 1);
     1249 +                atomic_inc_32(&vp->v_wrcnt);
1250 1250  
1251 1251  }
1252 1252  
1253 1253  void
1254 1254  vn_open_downgrade(
1255 1255          vnode_t *vp,
1256 1256          int filemode)
1257 1257  {
1258 1258          ASSERT(vp->v_type == VREG);
1259 1259  
1260 1260          if (filemode & FREAD) {
1261 1261                  ASSERT(vp->v_rdcnt > 0);
1262      -                atomic_add_32(&(vp->v_rdcnt), -1);
     1262 +                atomic_dec_32(&vp->v_rdcnt);
1263 1263          }
1264 1264          if (filemode & FWRITE) {
1265 1265                  ASSERT(vp->v_wrcnt > 0);
1266      -                atomic_add_32(&(vp->v_wrcnt), -1);
     1266 +                atomic_dec_32(&vp->v_wrcnt);
1267 1267          }
1268 1268  
1269 1269  }
1270 1270  
1271 1271  int
1272 1272  vn_create(
1273 1273          char *pnamep,
1274 1274          enum uio_seg seg,
1275 1275          struct vattr *vap,
1276 1276          enum vcexcl excl,
↓ open down ↓ 1634 lines elided ↑ open up ↑ 
2911 2911   * fs_new_caller_id() needs to return a unique ID on a given local system.
2912 2912   * The IDs do not need to survive across reboots.  These are primarily
2913 2913   * used so that (FEM) monitors can detect particular callers (such as
2914 2914   * the NFS server) to a given vnode/vfs operation.
2915 2915   */
2916 2916  u_longlong_t
2917 2917  fs_new_caller_id()
2918 2918  {
2919 2919          static uint64_t next_caller_id = 0LL; /* First call returns 1 */
2920 2920  
2921      -        return ((u_longlong_t)atomic_add_64_nv(&next_caller_id, 1));
     2921 +        return ((u_longlong_t)atomic_inc_64_nv(&next_caller_id));
2922 2922  }
2923 2923  
2924 2924  /*
2925 2925   * Given a starting vnode and a path, updates the path in the target vnode in
2926 2926   * a safe manner.  If the vnode already has path information embedded, then the
2927 2927   * cached path is left untouched.
2928 2928   */
2929 2929  
2930 2930  size_t max_vnode_path = 4 * MAXPATHLEN;
2931 2931
↓ open down ↓ 207 lines elided ↑ open up ↑ 
3139 3139           * false negative. The inquirer goes away believing the file is
3140 3140           * not open when there is an open on the file already under way.
3141 3141           *
3142 3142           * The counts are meant to prevent NFS from granting a delegation
3143 3143           * when it would be dangerous to do so.
3144 3144           *
3145 3145           * The vnode counts are only kept on regular files
3146 3146           */
3147 3147          if ((*vpp)->v_type == VREG) {
3148 3148                  if (mode & FREAD)
3149      -                        atomic_add_32(&((*vpp)->v_rdcnt), 1);
     3149 +                        atomic_inc_32(&(*vpp)->v_rdcnt);
3150 3150                  if (mode & FWRITE)
3151      -                        atomic_add_32(&((*vpp)->v_wrcnt), 1);
     3151 +                        atomic_inc_32(&(*vpp)->v_wrcnt);
3152 3152          }
3153 3153  
3154 3154          VOPXID_MAP_CR(vp, cr);
3155 3155  
3156 3156          ret = (*(*(vpp))->v_op->vop_open)(vpp, mode, cr, ct);
3157 3157  
3158 3158          if (ret) {
3159 3159                  /*
3160 3160                   * Use the saved vp just in case the vnode ptr got trashed
3161 3161                   * by the error.
3162 3162                   */
3163 3163                  VOPSTATS_UPDATE(vp, open);
3164 3164                  if ((vp->v_type == VREG) && (mode & FREAD))
3165      -                        atomic_add_32(&(vp->v_rdcnt), -1);
     3165 +                        atomic_dec_32(&vp->v_rdcnt);
3166 3166                  if ((vp->v_type == VREG) && (mode & FWRITE))
3167      -                        atomic_add_32(&(vp->v_wrcnt), -1);
     3167 +                        atomic_dec_32(&vp->v_wrcnt);
3168 3168          } else {
3169 3169                  /*
3170 3170                   * Some filesystems will return a different vnode,
3171 3171                   * but the same path was still used to open it.
3172 3172                   * So if we do change the vnode and need to
3173 3173                   * copy over the path, do so here, rather than special
3174 3174                   * casing each filesystem. Adjust the vnode counts to
3175 3175                   * reflect the vnode switch.
3176 3176                   */
3177 3177                  VOPSTATS_UPDATE(*vpp, open);
3178 3178                  if (*vpp != vp && *vpp != NULL) {
3179 3179                          vn_copypath(vp, *vpp);
3180 3180                          if (((*vpp)->v_type == VREG) && (mode & FREAD))
3181      -                                atomic_add_32(&((*vpp)->v_rdcnt), 1);
     3181 +                                atomic_inc_32(&(*vpp)->v_rdcnt);
3182 3182                          if ((vp->v_type == VREG) && (mode & FREAD))
3183      -                                atomic_add_32(&(vp->v_rdcnt), -1);
     3183 +                                atomic_dec_32(&vp->v_rdcnt);
3184 3184                          if (((*vpp)->v_type == VREG) && (mode & FWRITE))
3185      -                                atomic_add_32(&((*vpp)->v_wrcnt), 1);
     3185 +                                atomic_inc_32(&(*vpp)->v_wrcnt);
3186 3186                          if ((vp->v_type == VREG) && (mode & FWRITE))
3187      -                                atomic_add_32(&(vp->v_wrcnt), -1);
     3187 +                                atomic_dec_32(&vp->v_wrcnt);
3188 3188                  }
3189 3189          }
3190 3190          VN_RELE(vp);
3191 3191          return (ret);
3192 3192  }
3193 3193  
3194 3194  int
3195 3195  fop_close(
3196 3196          vnode_t *vp,
3197 3197          int flag,
↓ open down ↓ 8 lines elided ↑ open up ↑ 
3206 3206  
3207 3207          err = (*(vp)->v_op->vop_close)(vp, flag, count, offset, cr, ct);
3208 3208          VOPSTATS_UPDATE(vp, close);
3209 3209          /*
3210 3210           * Check passed in count to handle possible dups. Vnode counts are only
3211 3211           * kept on regular files
3212 3212           */
3213 3213          if ((vp->v_type == VREG) && (count == 1))  {
3214 3214                  if (flag & FREAD) {
3215 3215                          ASSERT(vp->v_rdcnt > 0);
3216      -                        atomic_add_32(&(vp->v_rdcnt), -1);
     3216 +                        atomic_dec_32(&vp->v_rdcnt);
3217 3217                  }
3218 3218                  if (flag & FWRITE) {
3219 3219                          ASSERT(vp->v_wrcnt > 0);
3220      -                        atomic_add_32(&(vp->v_wrcnt), -1);
     3220 +                        atomic_dec_32(&vp->v_wrcnt);
3221 3221                  }
3222 3222          }
3223 3223          return (err);
3224 3224  }
3225 3225  
3226 3226  int
3227 3227  fop_read(
3228 3228          vnode_t *vp,
3229 3229          uio_t *uiop,
3230 3230          int ioflag,
↓ open down ↓ 1317 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX