VirtualBox

Changeset 39297 in vbox


Ignore:
Timestamp:
Nov 14, 2011 4:46:52 PM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
74849
Message:

Additions/solaris/SharedFolders: Pass file/dir mode directly to create/mkdir calls instead of using set_attr explicitly after each call.

Location:
trunk/src/VBox/Additions/solaris/SharedFolders
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/solaris/SharedFolders/vboxfs_prov.c

    r39295 r39297  
    189189        fsinfo->maxnamesize = info.fsProperties.cbMaxComponent;
    190190        fsinfo->readonly = info.fsProperties.fReadOnly;
    191         return (0);
    192 }
    193 
    194 /*
    195  * File operations: open/close/read/write/etc.
    196  *
    197  * open/create can return any relevant errno, however ENOENT
    198  * generally means that the host file didn't exist.
    199  */
    200 struct sfp_file {
    201         SHFLHANDLE handle;
    202         VBSFMAP map;    /* need this again for the close operation */
    203 };
    204 
    205 int
    206 sfprov_create(sfp_mount_t *mnt, char *path, sfp_file_t **fp)
    207 {
    208 
    209         int rc;
    210         SHFLCREATEPARMS parms;
    211         SHFLSTRING *str;
    212         int size;
    213         sfp_file_t *newfp;
    214 
    215         str = sfprov_string(path, &size);
    216         parms.Handle = 0;
    217         parms.Info.cbObject = 0;
    218         parms.CreateFlags = SHFL_CF_ACT_CREATE_IF_NEW |
    219             SHFL_CF_ACT_REPLACE_IF_EXISTS | SHFL_CF_ACCESS_READWRITE;
    220         rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
    221         kmem_free(str, size);
    222 
    223         if (RT_FAILURE(rc))
    224         {
    225                 if (rc != VERR_ACCESS_DENIED && rc != VERR_WRITE_PROTECT)
    226                         cmn_err(CE_WARN, "sfprov_create: vboxCallCreate failed! path=%s rc=%d\n", path, rc);
    227                 return (sfprov_vbox2errno(rc));
    228         }
    229         if (parms.Handle == SHFL_HANDLE_NIL) {
    230                 if (parms.Result == SHFL_FILE_EXISTS)
    231                         return (EEXIST);
    232                 return (ENOENT);
    233         }
    234         newfp = kmem_alloc(sizeof(sfp_file_t), KM_SLEEP);
    235         newfp->handle = parms.Handle;
    236         newfp->map = mnt->map;
    237         *fp = newfp;
    238         return (0);
    239 }
    240 
    241 int
    242 sfprov_open(sfp_mount_t *mnt, char *path, sfp_file_t **fp)
    243 {
    244         int rc;
    245         SHFLCREATEPARMS parms;
    246         SHFLSTRING *str;
    247         int size;
    248         sfp_file_t *newfp;
    249 
    250         /*
    251          * First we attempt to open it read/write. If that fails we
    252          * try read only.
    253          */
    254         bzero(&parms, sizeof(parms));
    255         str = sfprov_string(path, &size);
    256         parms.Handle = SHFL_HANDLE_NIL;
    257         parms.Info.cbObject = 0;
    258         parms.CreateFlags = SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READWRITE;
    259         rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
    260         if (RT_FAILURE(rc) && rc != VERR_ACCESS_DENIED) {
    261                 kmem_free(str, size);
    262                 return (sfprov_vbox2errno(rc));
    263         }
    264         if (parms.Handle == SHFL_HANDLE_NIL) {
    265                 if (parms.Result == SHFL_PATH_NOT_FOUND ||
    266                     parms.Result == SHFL_FILE_NOT_FOUND) {
    267                         kmem_free(str, size);
    268                         return (ENOENT);
    269                 }
    270                 parms.CreateFlags =
    271                     SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
    272                 rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
    273                 if (RT_FAILURE(rc)) {
    274                         kmem_free(str, size);
    275                         return (sfprov_vbox2errno(rc));
    276                 }
    277                 if (parms.Handle == SHFL_HANDLE_NIL) {
    278                         kmem_free(str, size);
    279                         return (ENOENT);
    280                 }
    281         }
    282         else
    283                 kmem_free(str, size);
    284         newfp = kmem_alloc(sizeof(sfp_file_t), KM_SLEEP);
    285         newfp->handle = parms.Handle;
    286         newfp->map = mnt->map;
    287         *fp = newfp;
    288         return (0);
    289 }
    290 
    291 int
    292 sfprov_trunc(sfp_mount_t *mnt, char *path)
    293 {
    294         int rc;
    295         SHFLCREATEPARMS parms;
    296         SHFLSTRING *str;
    297         int size;
    298 
    299         /*
    300          * open it read/write.
    301          */
    302         str = sfprov_string(path, &size);
    303         parms.Handle = 0;
    304         parms.Info.cbObject = 0;
    305         parms.CreateFlags = SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READWRITE |
    306             SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
    307         rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
    308         kmem_free(str, size);
    309 
    310         if (RT_FAILURE(rc)) {
    311                 return (EINVAL);
    312         }
    313         (void)vboxCallClose(&vbox_client, &mnt->map, parms.Handle);
    314         return (0);
    315 }
    316 
    317 int
    318 sfprov_close(sfp_file_t *fp)
    319 {
    320         int rc;
    321 
    322         rc = vboxCallClose(&vbox_client, &fp->map, fp->handle);
    323         kmem_free(fp, sizeof(sfp_file_t));
    324         return (0);
    325 }
    326 
    327 int
    328 sfprov_read(sfp_file_t *fp, char *buffer, uint64_t offset, uint32_t *numbytes)
    329 {
    330         int rc;
    331 
    332         rc = vboxCallRead(&vbox_client, &fp->map, fp->handle, offset,
    333             numbytes, (uint8_t *)buffer, 0);    /* what is that last arg? */
    334         if (RT_FAILURE(rc))
    335                 return (EINVAL);
    336         return (0);
    337 }
    338 
    339 int
    340 sfprov_write(sfp_file_t *fp, char *buffer, uint64_t offset, uint32_t *numbytes)
    341 {
    342         int rc;
    343 
    344         rc = vboxCallWrite(&vbox_client, &fp->map, fp->handle, offset,
    345             numbytes, (uint8_t *)buffer, 0);    /* what is that last arg? */
    346         if (RT_FAILURE(rc))
    347                 return (EINVAL);
    348         return (0);
    349 }
    350 
    351 int
    352 sfprov_fsync(sfp_file_t *fp)
    353 {
    354         int rc;
    355 
    356         rc = vboxCallFlush(&vbox_client, &fp->map, fp->handle);
    357         if (RT_FAILURE(rc))
    358                 return (EIO);
    359         return (0);
    360 }
    361 
    362 
    363 static int
    364 sfprov_getinfo(sfp_mount_t *mnt, char *path, PSHFLFSOBJINFO info)
    365 {
    366         int rc;
    367         SHFLCREATEPARMS parms;
    368         SHFLSTRING *str;
    369         int size;
    370 
    371         str = sfprov_string(path, &size);
    372         parms.Handle = 0;
    373         parms.Info.cbObject = 0;
    374         parms.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
    375         rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
    376         kmem_free(str, size);
    377 
    378         if (RT_FAILURE(rc))
    379                 return (EINVAL);
    380         if (parms.Result != SHFL_FILE_EXISTS)
    381                 return (ENOENT);
    382         *info = parms.Info;
    383191        return (0);
    384192}
    … …  
    473281}
    474282
    475 /*
    476  * get information about a file (or directory)
    477  */
    478 int
    479 sfprov_get_mode(sfp_mount_t *mnt, char *path, mode_t *mode)
    480 {
    481         int rc;
    482         SHFLFSOBJINFO info;
    483 
    484         rc = sfprov_getinfo(mnt, path, &info);
    485         if (rc)
    486                 return (rc);
    487         sfprov_mode_from_fmode(mode, info.Attr.fMode);
    488         return (0);
    489 }
    490 
    491 int
    492 sfprov_get_size(sfp_mount_t *mnt, char *path, uint64_t *size)
    493 {
    494         int rc;
    495         SHFLFSOBJINFO info;
    496 
    497         rc = sfprov_getinfo(mnt, path, &info);
    498         if (rc)
    499                 return (rc);
    500         *size = info.cbObject;
    501         return (0);
    502 }
    503 
    504283static void
    505284sfprov_ftime_from_timespec(timestruc_t *time, RTTIMESPEC *ts)
    … …  
    520299        sfprov_ftime_from_timespec(&stat->sf_ctime, &info->ChangeTime);
    521300}
     301
     302/*
     303 * File operations: open/close/read/write/etc.
     304 *
     305 * open/create can return any relevant errno, however ENOENT
     306 * generally means that the host file didn't exist.
     307 */
     308struct sfp_file {
     309        SHFLHANDLE handle;
     310        VBSFMAP map;    /* need this again for the close operation */
     311};
     312
     313int
     314sfprov_create(
     315        sfp_mount_t *mnt,
     316        char *path,
     317        mode_t mode,
     318        sfp_file_t **fp,
     319        sffs_stat_t *stat)
     320{
     321
     322        int rc;
     323        SHFLCREATEPARMS parms;
     324        SHFLSTRING *str;
     325        int size;
     326        sfp_file_t *newfp;
     327
     328        str = sfprov_string(path, &size);
     329        parms.Handle = SHFL_HANDLE_NIL;
     330        parms.Info.cbObject = 0;
     331        sfprov_fmode_from_mode(&parms.Info.Attr.fMode, mode);
     332        parms.CreateFlags = SHFL_CF_ACT_CREATE_IF_NEW |
     333            SHFL_CF_ACT_REPLACE_IF_EXISTS | SHFL_CF_ACCESS_READWRITE;
     334        rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
     335        kmem_free(str, size);
     336
     337        if (RT_FAILURE(rc))
     338        {
     339                if (rc != VERR_ACCESS_DENIED && rc != VERR_WRITE_PROTECT)
     340                        cmn_err(CE_WARN, "sfprov_create: vboxCallCreate failed! path=%s rc=%d\n", path, rc);
     341                return (sfprov_vbox2errno(rc));
     342        }
     343        if (parms.Handle == SHFL_HANDLE_NIL) {
     344                if (parms.Result == SHFL_FILE_EXISTS)
     345                        return (EEXIST);
     346                return (ENOENT);
     347        }
     348        newfp = kmem_alloc(sizeof(sfp_file_t), KM_SLEEP);
     349        newfp->handle = parms.Handle;
     350        newfp->map = mnt->map;
     351        *fp = newfp;
     352        sfprov_stat_from_info(stat, &parms.Info);
     353        return (0);
     354}
     355
     356int
     357sfprov_open(sfp_mount_t *mnt, char *path, sfp_file_t **fp)
     358{
     359        int rc;
     360        SHFLCREATEPARMS parms;
     361        SHFLSTRING *str;
     362        int size;
     363        sfp_file_t *newfp;
     364
     365        /*
     366         * First we attempt to open it read/write. If that fails we
     367         * try read only.
     368         */
     369        bzero(&parms, sizeof(parms));
     370        str = sfprov_string(path, &size);
     371        parms.Handle = SHFL_HANDLE_NIL;
     372        parms.Info.cbObject = 0;
     373        parms.CreateFlags = SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READWRITE;
     374        rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
     375        if (RT_FAILURE(rc) && rc != VERR_ACCESS_DENIED) {
     376                kmem_free(str, size);
     377                return (sfprov_vbox2errno(rc));
     378        }
     379        if (parms.Handle == SHFL_HANDLE_NIL) {
     380                if (parms.Result == SHFL_PATH_NOT_FOUND ||
     381                    parms.Result == SHFL_FILE_NOT_FOUND) {
     382                        kmem_free(str, size);
     383                        return (ENOENT);
     384                }
     385                parms.CreateFlags =
     386                    SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
     387                rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
     388                if (RT_FAILURE(rc)) {
     389                        kmem_free(str, size);
     390                        return (sfprov_vbox2errno(rc));
     391                }
     392                if (parms.Handle == SHFL_HANDLE_NIL) {
     393                        kmem_free(str, size);
     394                        return (ENOENT);
     395                }
     396        }
     397        else
     398                kmem_free(str, size);
     399        newfp = kmem_alloc(sizeof(sfp_file_t), KM_SLEEP);
     400        newfp->handle = parms.Handle;
     401        newfp->map = mnt->map;
     402        *fp = newfp;
     403        return (0);
     404}
     405
     406int
     407sfprov_trunc(sfp_mount_t *mnt, char *path)
     408{
     409        int rc;
     410        SHFLCREATEPARMS parms;
     411        SHFLSTRING *str;
     412        int size;
     413
     414        /*
     415         * open it read/write.
     416         */
     417        str = sfprov_string(path, &size);
     418        parms.Handle = 0;
     419        parms.Info.cbObject = 0;
     420        parms.CreateFlags = SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READWRITE |
     421            SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
     422        rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
     423        kmem_free(str, size);
     424
     425        if (RT_FAILURE(rc)) {
     426                return (EINVAL);
     427        }
     428        (void)vboxCallClose(&vbox_client, &mnt->map, parms.Handle);
     429        return (0);
     430}
     431
     432int
     433sfprov_close(sfp_file_t *fp)
     434{
     435        int rc;
     436
     437        rc = vboxCallClose(&vbox_client, &fp->map, fp->handle);
     438        kmem_free(fp, sizeof(sfp_file_t));
     439        return (0);
     440}
     441
     442int
     443sfprov_read(sfp_file_t *fp, char *buffer, uint64_t offset, uint32_t *numbytes)
     444{
     445        int rc;
     446
     447        rc = vboxCallRead(&vbox_client, &fp->map, fp->handle, offset,
     448            numbytes, (uint8_t *)buffer, 0);    /* what is that last arg? */
     449        if (RT_FAILURE(rc))
     450                return (EINVAL);
     451        return (0);
     452}
     453
     454int
     455sfprov_write(sfp_file_t *fp, char *buffer, uint64_t offset, uint32_t *numbytes)
     456{
     457        int rc;
     458
     459        rc = vboxCallWrite(&vbox_client, &fp->map, fp->handle, offset,
     460            numbytes, (uint8_t *)buffer, 0);    /* what is that last arg? */
     461        if (RT_FAILURE(rc))
     462                return (EINVAL);
     463        return (0);
     464}
     465
     466int
     467sfprov_fsync(sfp_file_t *fp)
     468{
     469        int rc;
     470
     471        rc = vboxCallFlush(&vbox_client, &fp->map, fp->handle);
     472        if (RT_FAILURE(rc))
     473                return (EIO);
     474        return (0);
     475}
     476
     477
     478static int
     479sfprov_getinfo(sfp_mount_t *mnt, char *path, PSHFLFSOBJINFO info)
     480{
     481        int rc;
     482        SHFLCREATEPARMS parms;
     483        SHFLSTRING *str;
     484        int size;
     485
     486        str = sfprov_string(path, &size);
     487        parms.Handle = 0;
     488        parms.Info.cbObject = 0;
     489        parms.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
     490        rc = vboxCallCreate(&vbox_client, &mnt->map, str, &parms);
     491        kmem_free(str, size);
     492
     493        if (RT_FAILURE(rc))
     494                return (EINVAL);
     495        if (parms.Result != SHFL_FILE_EXISTS)
     496                return (ENOENT);
     497        *info = parms.Info;
     498        return (0);
     499}
     500
     501/*
     502 * get information about a file (or directory)
     503 */
     504int
     505sfprov_get_mode(sfp_mount_t *mnt, char *path, mode_t *mode)
     506{
     507        int rc;
     508        SHFLFSOBJINFO info;
     509
     510        rc = sfprov_getinfo(mnt, path, &info);
     511        if (rc)
     512                return (rc);
     513        sfprov_mode_from_fmode(mode, info.Attr.fMode);
     514        return (0);
     515}
     516
     517int
     518sfprov_get_size(sfp_mount_t *mnt, char *path, uint64_t *size)
     519{
     520        int rc;
     521        SHFLFSOBJINFO info;
     522
     523        rc = sfprov_getinfo(mnt, path, &info);
     524        if (rc)
     525                return (rc);
     526        *size = info.cbObject;
     527        return (0);
     528}
     529
    522530
    523531int
    … …  
    712720 */
    713721int
    714 sfprov_mkdir(sfp_mount_t *mnt, char *path, sfp_file_t **fp)
     722sfprov_mkdir(
     723        sfp_mount_t *mnt,
     724        char *path,
     725        mode_t mode,
     726        sfp_file_t **fp,
     727        sffs_stat_t *stat)
    715728{
    716729        int rc;
    … …  
    721734
    722735        str = sfprov_string(path, &size);
    723         parms.Handle = 0;
     736        parms.Handle = SHFL_HANDLE_NIL;
    724737        parms.Info.cbObject = 0;
     738        sfprov_fmode_from_mode(&parms.Info.Attr.fMode, mode);
    725739        parms.CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_CREATE_IF_NEW |
    726740            SHFL_CF_ACT_FAIL_IF_EXISTS | SHFL_CF_ACCESS_READ;
    … …  
    739753        newfp->map = mnt->map;
    740754        *fp = newfp;
     755        sfprov_stat_from_info(stat, &parms.Info);
    741756        return (0);
    742757}

  • trunk/src/VBox/Additions/solaris/SharedFolders/vboxfs_prov.h

    r39278 r39297  
    8888 * generally means that the host file didn't exist.
    8989 */
     90typedef struct sffs_stat {
     91        mode_t          sf_mode;
     92        off_t           sf_size;
     93        off_t           sf_alloc;
     94        timestruc_t     sf_atime;
     95        timestruc_t     sf_mtime;
     96        timestruc_t     sf_ctime;
     97} sffs_stat_t;
     98
    9099typedef struct sfp_file sfp_file_t;
    91100
    92 extern int sfprov_create(sfp_mount_t *, char *path, sfp_file_t **fp);
     101extern int sfprov_create(sfp_mount_t *, char *path, mode_t mode,
     102    sfp_file_t **fp, sffs_stat_t *stat);
    93103extern int sfprov_open(sfp_mount_t *, char *path, sfp_file_t **fp);
    94104extern int sfprov_close(sfp_file_t *fp);
    … …  
    103113 * get/set information about a file (or directory) using pathname
    104114 */
    105 typedef struct sffs_stat {
    106         mode_t          sf_mode;
    107         off_t           sf_size;
    108         off_t           sf_alloc;
    109         timestruc_t     sf_atime;
    110         timestruc_t     sf_mtime;
    111         timestruc_t     sf_ctime;
    112 } sffs_stat_t;
    113 
    114115extern int sfprov_get_mode(sfp_mount_t *, char *, mode_t *);
    115116extern int sfprov_get_size(sfp_mount_t *, char *, uint64_t *);
    … …  
    128129extern int sfprov_trunc(sfp_mount_t *, char *);
    129130extern int sfprov_remove(sfp_mount_t *, char *path, uint_t is_link);
    130 extern int sfprov_mkdir(sfp_mount_t *, char *path, sfp_file_t **fp);
     131extern int sfprov_mkdir(sfp_mount_t *, char *path, mode_t mode,
     132    sfp_file_t **fp, sffs_stat_t *stat);
    131133extern int sfprov_rmdir(sfp_mount_t *, char *path);
    132134extern int sfprov_rename(sfp_mount_t *, char *from, char *to, uint_t is_dir);

  • trunk/src/VBox/Additions/solaris/SharedFolders/vboxfs_vnode.c

    r39272 r39297  
    535535        char *name,
    536536        vtype_t create,
     537        mode_t c_mode,
    537538        sffs_stat_t *stat,
    538539        uint64_t stat_time,
    … …  
    587588        if (create == VREG) {
    588589                type = VREG;
    589                 error = sfprov_create(dir->sf_sffs->sf_handle, fullpath, &fp);
     590                error = sfprov_create(dir->sf_sffs->sf_handle, fullpath, c_mode,
     591                                        &fp, stat);
     592                stat_time = sfnode_cur_time_usec();
    590593        } else if (create == VDIR) {
    591594                type = VDIR;
    592                 error = sfprov_mkdir(dir->sf_sffs->sf_handle, fullpath, &fp);
     595                error = sfprov_mkdir(dir->sf_sffs->sf_handle, fullpath, c_mode,
     596                                        &fp, stat);
     597                stat_time = sfnode_cur_time_usec();
    593598        } else {
    594599                mode_t m;
    … …  
    786791                } else {
    787792                        node = sfnode_lookup(dir, dirent->sf_entry.d_name, VNON,
    788                             &dirent->sf_stat, sfnode_cur_time_usec(), NULL);
     793                                0, &dirent->sf_stat, sfnode_cur_time_usec(), NULL);
    789794                        if (node == NULL)
    790795                                panic("sffs_readdir() lookup failed");
    … …  
    12171222         * Lookup the node.
    12181223         */
    1219         node = sfnode_lookup(VN2SFN(dvp), name, VNON, NULL, 0, NULL);
     1224        node = sfnode_lookup(VN2SFN(dvp), name, VNON, 0, NULL, 0, NULL);
    12201225        if (node != NULL)
    12211226                *vpp = sfnode_get_vnode(node);
    … …  
    13121317         */
    13131318        mutex_enter(&sffs_lock);
    1314         node = sfnode_lookup(VN2SFN(dvp), name, VNON, NULL, 0, NULL);
     1319        node = sfnode_lookup(VN2SFN(dvp), name, VNON, 0, NULL, 0, NULL);
    13151320        if (node != NULL) {
    13161321                mutex_exit(&sffs_lock);
    … …  
    13231328        sfnode_invalidate_stat_cache(VN2SFN(dvp));
    13241329        int lookuperr;
    1325         node = sfnode_lookup(VN2SFN(dvp), name, VREG, NULL, 0, &lookuperr);
    1326         if (node && (vap->va_mask & AT_MODE)) {
    1327                 timestruc_t dummy;
    1328                 error = sfprov_set_attr(node->sf_sffs->sf_handle, node->sf_path,
    1329                     AT_MODE, vap->va_mode, dummy, dummy, dummy);
    1330                 if (error)
    1331                         cmn_err(CE_WARN, "sffs_create: set_mode(%s, %o) failed"
    1332                             " rc=%d", node->sf_path, vap->va_mode, error);
    1333         }
     1330        node = sfnode_lookup(VN2SFN(dvp), name, VREG,
     1331                (vap->va_mask & AT_MODE) ? vap->va_mode : 0, NULL, 0, &lookuperr);
    13341332
    13351333        if (node && node->sf_parent)
    … …  
    13901388        sfnode_invalidate_stat_cache(VN2SFN(dvp));
    13911389        int lookuperr = EACCES;
    1392         node = sfnode_lookup(VN2SFN(dvp), nm, VDIR, NULL, 0, &lookuperr);
    1393         if (node && (va->va_mask & AT_MODE)) {
    1394                 timestruc_t dummy;
    1395                 error = sfprov_set_attr(node->sf_sffs->sf_handle, node->sf_path,
    1396                     AT_MODE, va->va_mode, dummy, dummy, dummy);
    1397                 if (error)
    1398                         cmn_err(CE_WARN, "sffs_mkdir: set_mode(%s, %o) failed"
    1399                             " rc=%d", node->sf_path, va->va_mode, error);
    1400         }
     1390        node = sfnode_lookup(VN2SFN(dvp), nm, VDIR,
     1391                (va->va_mode & AT_MODE) ? va->va_mode : 0, NULL, 0, &lookuperr);
    14011392
    14021393        if (node && node->sf_parent)
    … …  
    19631954        mutex_enter(&sffs_lock);
    19641955
    1965         if (sfnode_lookup(VN2SFN(dvp), linkname, VNON, NULL, 0, NULL) != NULL) {
     1956        if (sfnode_lookup(VN2SFN(dvp), linkname, VNON, 0, NULL, 0, NULL) !=
     1957                NULL) {
    19661958                error = EEXIST;
    19671959                goto done;
    … …  
    19841976                goto done;
    19851977
    1986         node = sfnode_lookup(dir, linkname, VLNK, &stat, sfnode_cur_time_usec(),
    1987             NULL);
     1978        node = sfnode_lookup(dir, linkname, VLNK, 0, &stat,
     1979                sfnode_cur_time_usec(), NULL);
    19881980
    19891981        sfnode_invalidate_stat_cache(dir);
    … …  
    20932085                goto done;
    20942086
    2095         node = sfnode_lookup(VN2SFN(old_dir), old_nm, VNON, NULL, 0, NULL);
     2087        node = sfnode_lookup(VN2SFN(old_dir), old_nm, VNON, 0, NULL, 0, NULL);
    20962088        if (node == NULL) {
    20972089                error = ENOENT;
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette