|
nfs-ganesha 1.4
|
00001 /* 00002 * vim:expandtab:shiftwidth=4:tabstop=4: 00003 */ 00004 00015 #ifdef HAVE_CONFIG_H 00016 #include "config.h" 00017 #endif 00018 #include "fsal_convert.h" 00019 #include "fsal_internal.h" 00020 #include "nfs4_acls.h" 00021 #include "gpfs.h" 00022 #include <sys/types.h> 00023 #include <sys/stat.h> 00024 #include <errno.h> 00025 #include <string.h> 00026 #include <fcntl.h> 00027 #include <sys/resource.h> 00028 00029 #define MAX_2( x, y ) ( (x) > (y) ? (x) : (y) ) 00030 #define MAX_3( x, y, z ) ( (x) > (y) ? MAX_2((x),(z)) : MAX_2((y),(z)) ) 00031 extern uint32_t open_fd_count; 00032 00033 #ifdef _USE_NFS4_ACL 00034 static int gpfs_acl_2_fsal_acl(fsal_attrib_list_t * p_object_attributes, 00035 gpfs_acl_t *p_gpfsacl); 00036 #endif /* _USE_NFS4_ACL */ 00037 00049 int posix2fsal_error(int posix_errorcode) 00050 { 00051 struct rlimit rlim = { 00052 .rlim_cur = RLIM_INFINITY, 00053 .rlim_max = RLIM_INFINITY 00054 }; 00055 00056 switch (posix_errorcode) 00057 { 00058 00059 case EPERM: 00060 return ERR_FSAL_PERM; 00061 00062 case ENOENT: 00063 return ERR_FSAL_NOENT; 00064 00065 /* connection error */ 00066 #ifdef _AIX_5 00067 case ENOCONNECT: 00068 #elif defined _LINUX 00069 case ECONNREFUSED: 00070 case ECONNABORTED: 00071 case ECONNRESET: 00072 #endif 00073 00074 /* IO error */ 00075 case EIO: 00076 00077 /* too many open files */ 00078 case ENFILE: 00079 case EMFILE: 00080 00081 /* broken pipe */ 00082 case EPIPE: 00083 00084 /* all shown as IO errors */ 00085 if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) { 00086 LogCrit(COMPONENT_FSAL, "%s mapping %d to ERR_FSAL_IO, open_fd_count=%d getrlimit failed", 00087 __FUNCTION__, posix_errorcode, open_fd_count); 00088 } 00089 else { 00090 LogCrit(COMPONENT_FSAL, "%s mapping %d to ERR_FSAL_IO, open_fd_count=%d rlim_cur=%ld rlim_max=%ld", 00091 __FUNCTION__, posix_errorcode, open_fd_count, rlim.rlim_cur, rlim.rlim_max); 00092 } 00093 return ERR_FSAL_IO; 00094 00095 /* no such device */ 00096 case ENODEV: 00097 case ENXIO: 00098 LogCrit(COMPONENT_FSAL, "%s mapping %d to ERR_FSAL_NXIO", 00099 __FUNCTION__, posix_errorcode); 00100 return ERR_FSAL_NXIO; 00101 00102 /* invalid file descriptor : */ 00103 case EBADF: 00104 /* we suppose it was not opened... */ 00105 00113 return ERR_FSAL_NOT_OPENED; 00114 00115 case ENOMEM: 00116 case ENOLCK: 00117 return ERR_FSAL_NOMEM; 00118 00119 case EACCES: 00120 return ERR_FSAL_ACCESS; 00121 00122 case EFAULT: 00123 return ERR_FSAL_FAULT; 00124 00125 case EEXIST: 00126 return ERR_FSAL_EXIST; 00127 00128 case EXDEV: 00129 return ERR_FSAL_XDEV; 00130 00131 case ENOTDIR: 00132 return ERR_FSAL_NOTDIR; 00133 00134 case EISDIR: 00135 return ERR_FSAL_ISDIR; 00136 00137 case EINVAL: 00138 return ERR_FSAL_INVAL; 00139 00140 case EFBIG: 00141 return ERR_FSAL_FBIG; 00142 00143 case ETXTBSY: 00144 return ERR_FSAL_FILE_OPEN; 00145 00146 case ENOSPC: 00147 return ERR_FSAL_NOSPC; 00148 00149 case EMLINK: 00150 return ERR_FSAL_MLINK; 00151 00152 case EDQUOT: 00153 return ERR_FSAL_DQUOT; 00154 00155 case ENAMETOOLONG: 00156 return ERR_FSAL_NAMETOOLONG; 00157 00164 #ifdef _AIX 00165 case 87: 00166 #else 00167 case ENOTEMPTY: 00168 case -ENOTEMPTY: 00169 #endif 00170 return ERR_FSAL_NOTEMPTY; 00171 00172 case ESTALE: 00173 return ERR_FSAL_STALE; 00174 00175 /* Error code that needs a retry */ 00176 case EAGAIN: 00177 case EBUSY: 00178 00179 return ERR_FSAL_DELAY; 00180 00181 case ENOTSUP: 00182 return ERR_FSAL_NOTSUPP; 00183 00184 case EOVERFLOW: 00185 return ERR_FSAL_OVERFLOW; 00186 00187 case EDEADLK: 00188 return ERR_FSAL_DEADLOCK; 00189 00190 case EINTR: 00191 return ERR_FSAL_INTERRUPT; 00192 00193 default: 00194 00195 /* other unexpected errors */ 00196 return ERR_FSAL_SERVERFAULT; 00197 00198 } 00199 00200 } 00201 00202 00216 int fsal2posix_openflags(fsal_openflags_t fsal_flags, int *p_posix_flags) 00217 { 00218 int cpt; 00219 00220 if(!p_posix_flags) 00221 return ERR_FSAL_FAULT; 00222 00223 /* check that all used flags exist */ 00224 00225 if(fsal_flags & 00226 ~(FSAL_O_RDONLY | FSAL_O_RDWR | FSAL_O_WRONLY | FSAL_O_APPEND | 00227 FSAL_O_TRUNC | FSAL_O_SYNC)) 00228 return ERR_FSAL_INVAL; 00229 00230 /* Check for flags compatibility */ 00231 00232 /* O_RDONLY O_WRONLY O_RDWR cannot be used together */ 00233 00234 cpt = 0; 00235 if(fsal_flags & FSAL_O_RDONLY) 00236 cpt++; 00237 if(fsal_flags & FSAL_O_RDWR) 00238 cpt++; 00239 if(fsal_flags & FSAL_O_WRONLY) 00240 cpt++; 00241 00242 if(cpt > 1) 00243 return ERR_FSAL_INVAL; 00244 00245 /* FSAL_O_APPEND et FSAL_O_TRUNC cannot be used together */ 00246 00247 if((fsal_flags & FSAL_O_APPEND) && (fsal_flags & FSAL_O_TRUNC)) 00248 return ERR_FSAL_INVAL; 00249 00250 /* FSAL_O_TRUNC without FSAL_O_WRONLY or FSAL_O_RDWR */ 00251 00252 if((fsal_flags & FSAL_O_TRUNC) && !(fsal_flags & (FSAL_O_WRONLY | FSAL_O_RDWR))) 00253 return ERR_FSAL_INVAL; 00254 00255 /* conversion */ 00256 *p_posix_flags = 0; 00257 00258 if(fsal_flags & FSAL_O_RDONLY) 00259 *p_posix_flags |= O_RDONLY; 00260 if(fsal_flags & FSAL_O_WRONLY) 00261 *p_posix_flags |= O_WRONLY; 00262 if(fsal_flags & FSAL_O_RDWR) 00263 *p_posix_flags |= O_RDWR; 00264 if(fsal_flags & FSAL_O_SYNC) 00265 *p_posix_flags |= O_SYNC; 00266 00267 return ERR_FSAL_NO_ERROR; 00268 00269 } 00270 00271 fsal_status_t posix2fsal_attributes(struct stat * p_buffstat, 00272 fsal_attrib_list_t * p_fsalattr_out) 00273 { 00274 00275 fsal_attrib_mask_t supp_attr, unsupp_attr; 00276 00277 /* sanity checks */ 00278 if(!p_buffstat || !p_fsalattr_out) 00279 ReturnCode(ERR_FSAL_FAULT, 0); 00280 00281 /* check that asked attributes are supported */ 00282 supp_attr = global_fs_info.supported_attrs; 00283 00284 unsupp_attr = (p_fsalattr_out->asked_attributes) & (~supp_attr); 00285 if(unsupp_attr) 00286 { 00287 LogFullDebug(COMPONENT_FSAL, "Unsupported attributes: %#llX", 00288 unsupp_attr); 00289 ReturnCode(ERR_FSAL_ATTRNOTSUPP, 0); 00290 } 00291 00292 /* Initialize ACL regardless of whether ACL was asked or not. 00293 * This is needed to make sure ACL attribute is initialized. */ 00294 p_fsalattr_out->acl = NULL; 00295 00296 /* Fills the output struct */ 00297 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SUPPATTR)) 00298 { 00299 p_fsalattr_out->supported_attributes = supp_attr; 00300 } 00301 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_TYPE)) 00302 { 00303 p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode); 00304 } 00305 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SIZE)) 00306 { 00307 p_fsalattr_out->filesize = p_buffstat->st_size; 00308 } 00309 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FSID)) 00310 { 00311 p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev); 00312 } 00313 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ACL)) 00314 { 00315 p_fsalattr_out->acl = NULL; 00316 } 00317 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FILEID)) 00318 { 00319 p_fsalattr_out->fileid = (fsal_u64_t) (p_buffstat->st_ino); 00320 } 00321 00322 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MODE)) 00323 { 00324 p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode); 00325 } 00326 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_NUMLINKS)) 00327 { 00328 p_fsalattr_out->numlinks = p_buffstat->st_nlink; 00329 } 00330 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_OWNER)) 00331 { 00332 p_fsalattr_out->owner = p_buffstat->st_uid; 00333 } 00334 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_GROUP)) 00335 { 00336 p_fsalattr_out->group = p_buffstat->st_gid; 00337 } 00338 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ATIME)) 00339 { 00340 p_fsalattr_out->atime = posix2fsal_time(p_buffstat->st_atime, p_buffstat->st_atim.tv_nsec); 00341 } 00342 00343 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CTIME)) 00344 { 00345 p_fsalattr_out->ctime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); 00346 } 00347 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MTIME)) 00348 { 00349 p_fsalattr_out->mtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); 00350 } 00351 00352 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CHGTIME)) 00353 { 00354 if(p_buffstat->st_mtime == p_buffstat->st_ctime) 00355 { 00356 if(p_buffstat->st_mtim.tv_nsec > p_buffstat->st_ctim.tv_nsec) 00357 p_fsalattr_out->chgtime 00358 = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); 00359 else 00360 p_fsalattr_out->chgtime 00361 = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); 00362 } 00363 else if(p_buffstat->st_mtime > p_buffstat->st_ctime) 00364 { 00365 p_fsalattr_out->chgtime 00366 = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); 00367 } 00368 else 00369 { 00370 p_fsalattr_out->chgtime 00371 = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); 00372 } 00373 p_fsalattr_out->change = (uint64_t) p_fsalattr_out->chgtime.seconds + 00374 (uint64_t) p_fsalattr_out->chgtime.nseconds; 00375 } 00376 00377 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SPACEUSED)) 00378 { 00379 p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE; 00380 } 00381 00382 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_RAWDEV)) 00383 { 00384 p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev); /* XXX: convert ? */ 00385 } 00386 /* mounted_on_fileid : 00387 if ( FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, 00388 FSAL_ATTR_MOUNTFILEID )){ 00389 p_fsalattr_out->mounted_on_fileid = 00390 hpss2fsal_64( p_hpss_attr_in->FilesetRootId ); 00391 } 00392 */ 00393 00394 /* everything has been copied ! */ 00395 00396 ReturnCode(ERR_FSAL_NO_ERROR, 0); 00397 } 00398 00399 /* Same function as posixstat64_2_fsal_attributes. When NFS4 ACL support 00400 * is enabled, this will replace posixstat64_2_fsal_attributes. */ 00401 fsal_status_t gpfsfsal_xstat_2_fsal_attributes(gpfsfsal_xstat_t *p_buffxstat, 00402 fsal_attrib_list_t *p_fsalattr_out) 00403 { 00404 00405 fsal_attrib_mask_t supp_attr, unsupp_attr; 00406 struct stat *p_buffstat; 00407 00408 /* sanity checks */ 00409 if(!p_buffxstat || !p_fsalattr_out) 00410 ReturnCode(ERR_FSAL_FAULT, 0); 00411 00412 /* check that asked attributes are supported */ 00413 supp_attr = global_fs_info.supported_attrs; 00414 00415 unsupp_attr = (p_fsalattr_out->asked_attributes) & (~supp_attr); 00416 if(unsupp_attr) 00417 { 00418 LogFullDebug(COMPONENT_FSAL, "Unsupported attributes: %#llX", 00419 unsupp_attr); 00420 ReturnCode(ERR_FSAL_ATTRNOTSUPP, 0); 00421 } 00422 00423 p_buffstat = &p_buffxstat->buffstat; 00424 00425 /* Fills the output struct */ 00426 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SUPPATTR)) 00427 { 00428 p_fsalattr_out->supported_attributes = supp_attr; 00429 LogFullDebug(COMPONENT_FSAL, "supported_attributes = %llu", p_fsalattr_out->supported_attributes); 00430 } 00431 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_TYPE)) 00432 { 00433 p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode); 00434 LogFullDebug(COMPONENT_FSAL, "type = 0x%x", p_fsalattr_out->type); 00435 } 00436 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SIZE)) 00437 { 00438 p_fsalattr_out->filesize = p_buffstat->st_size; 00439 LogFullDebug(COMPONENT_FSAL, "filesize = %llu", 00440 (unsigned long long)p_fsalattr_out->filesize); 00441 } 00442 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FSID)) 00443 { 00444 p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev); 00445 LogFullDebug(COMPONENT_FSAL, "fsid major = %llu, minor = %llu", p_fsalattr_out->fsid.major, p_fsalattr_out->fsid.minor); 00446 } 00447 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ACL)) 00448 { 00449 #ifndef _USE_NFS4_ACL 00450 p_fsalattr_out->acl = NULL; 00451 #else 00452 if(p_buffxstat->attr_valid & XATTR_ACL) 00453 { 00454 /* ACL is valid, so try to convert fsal acl. */ 00455 if(gpfs_acl_2_fsal_acl(p_fsalattr_out, 00456 (gpfs_acl_t *)p_buffxstat->buffacl) != ERR_FSAL_NO_ERROR) 00457 p_fsalattr_out->acl = NULL; 00458 } 00459 #endif /* _USE_NFS4_ACL */ 00460 LogFullDebug(COMPONENT_FSAL, "acl = %p", p_fsalattr_out->acl); 00461 } 00462 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FILEID)) 00463 { 00464 p_fsalattr_out->fileid = (fsal_u64_t) (p_buffstat->st_ino); 00465 LogFullDebug(COMPONENT_FSAL, "fileid = %llu", p_fsalattr_out->fileid); 00466 } 00467 00468 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MODE)) 00469 { 00470 p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode); 00471 LogFullDebug(COMPONENT_FSAL, "mode = %llu", (long long unsigned int) p_fsalattr_out->mode); 00472 } 00473 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_NUMLINKS)) 00474 { 00475 p_fsalattr_out->numlinks = p_buffstat->st_nlink; 00476 LogFullDebug(COMPONENT_FSAL, "numlinks = %lu", p_fsalattr_out->numlinks); 00477 } 00478 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_OWNER)) 00479 { 00480 p_fsalattr_out->owner = p_buffstat->st_uid; 00481 LogFullDebug(COMPONENT_FSAL, "owner = %u", p_fsalattr_out->owner); 00482 } 00483 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_GROUP)) 00484 { 00485 p_fsalattr_out->group = p_buffstat->st_gid; 00486 LogFullDebug(COMPONENT_FSAL, "group = %u", p_fsalattr_out->group); 00487 } 00488 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ATIME)) 00489 { 00490 p_fsalattr_out->atime = posix2fsal_time(p_buffstat->st_atime, p_buffstat->st_atim.tv_nsec); 00491 LogFullDebug(COMPONENT_FSAL, "atime = %u", p_fsalattr_out->atime.seconds); 00492 } 00493 00494 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CTIME)) 00495 { 00496 p_fsalattr_out->ctime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); 00497 LogFullDebug(COMPONENT_FSAL, "ctime = %u", p_fsalattr_out->ctime.seconds); 00498 } 00499 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MTIME)) 00500 { 00501 p_fsalattr_out->mtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); 00502 LogFullDebug(COMPONENT_FSAL, "mtime = %u", p_fsalattr_out->mtime.seconds); 00503 } 00504 00505 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CHGTIME)) 00506 { 00507 if(p_buffstat->st_mtime == p_buffstat->st_ctime) 00508 { 00509 if(p_buffstat->st_mtim.tv_nsec > p_buffstat->st_ctim.tv_nsec) 00510 p_fsalattr_out->chgtime 00511 = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); 00512 else 00513 p_fsalattr_out->chgtime 00514 = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); 00515 } 00516 else if(p_buffstat->st_mtime > p_buffstat->st_ctime) 00517 { 00518 p_fsalattr_out->chgtime 00519 = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); 00520 } 00521 else 00522 { 00523 p_fsalattr_out->chgtime 00524 = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); 00525 } 00526 p_fsalattr_out->change = (uint64_t) p_fsalattr_out->chgtime.seconds + 00527 (uint64_t) p_fsalattr_out->chgtime.nseconds; 00528 LogFullDebug(COMPONENT_FSAL, "chgtime = %u", p_fsalattr_out->chgtime.seconds); 00529 00530 } 00531 00532 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SPACEUSED)) 00533 { 00534 p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE; 00535 LogFullDebug(COMPONENT_FSAL, "spaceused = %llu", 00536 (unsigned long long)p_fsalattr_out->spaceused); 00537 } 00538 00539 if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_RAWDEV)) 00540 { 00541 p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev); /* XXX: convert ? */ 00542 LogFullDebug(COMPONENT_FSAL, 00543 "rawdev major = %u, minor = %u", 00544 (unsigned int) p_fsalattr_out->rawdev.major, 00545 (unsigned int) p_fsalattr_out->rawdev.minor); 00546 } 00547 /* mounted_on_fileid : 00548 if ( FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, 00549 FSAL_ATTR_MOUNTFILEID )){ 00550 p_fsalattr_out->mounted_on_fileid = 00551 hpss2fsal_64( p_hpss_attr_in->FilesetRootId ); 00552 } 00553 */ 00554 00555 /* everything has been copied ! */ 00556 00557 ReturnCode(ERR_FSAL_NO_ERROR, 0); 00558 } 00559 00560 #ifdef _USE_NFS4_ACL 00561 /* Covert GPFS NFS4 ACLs to FSAL ACLs, and set the ACL 00562 * pointer of attribute. */ 00563 static int gpfs_acl_2_fsal_acl(fsal_attrib_list_t * p_object_attributes, 00564 gpfs_acl_t *p_gpfsacl) 00565 { 00566 fsal_acl_status_t status; 00567 fsal_acl_data_t acldata; 00568 fsal_ace_t *pace; 00569 fsal_acl_t *pacl; 00570 gpfs_ace_v4_t *pace_gpfs; 00571 00572 /* sanity checks */ 00573 if(!p_object_attributes || !p_gpfsacl) 00574 return ERR_FSAL_FAULT; 00575 00576 /* Create fsal acl data. */ 00577 acldata.naces = p_gpfsacl->acl_nace; 00578 acldata.aces = (fsal_ace_t *)nfs4_ace_alloc(acldata.naces); 00579 00580 /* Fill fsal acl data from gpfs acl. */ 00581 for(pace = acldata.aces, pace_gpfs = p_gpfsacl->ace_v4; 00582 pace < acldata.aces + acldata.naces; pace++, pace_gpfs++) 00583 { 00584 pace->type = pace_gpfs->aceType; 00585 pace->flag = pace_gpfs->aceFlags; 00586 pace->iflag = pace_gpfs->aceIFlags; 00587 pace->perm = pace_gpfs->aceMask; 00588 00589 if(IS_FSAL_ACE_SPECIAL_ID(*pace)) /* Record special user. */ 00590 { 00591 pace->who.uid = pace_gpfs->aceWho; 00592 } 00593 else 00594 { 00595 if(IS_FSAL_ACE_GROUP_ID(*pace)) /* Record group. */ 00596 pace->who.gid = pace_gpfs->aceWho; 00597 else /* Record user. */ 00598 pace->who.uid = pace_gpfs->aceWho; 00599 } 00600 00601 LogDebug(COMPONENT_FSAL, 00602 "gpfs_acl_2_fsal_acl: fsal ace: type = 0x%x, flag = 0x%x, perm = 0x%x, special = %d, %s = 0x%x", 00603 pace->type, pace->flag, pace->perm, IS_FSAL_ACE_SPECIAL_ID(*pace), 00604 GET_FSAL_ACE_WHO_TYPE(*pace), GET_FSAL_ACE_WHO(*pace)); 00605 } 00606 00607 /* Create a new hash table entry for fsal acl. */ 00608 pacl = nfs4_acl_new_entry(&acldata, &status); 00609 LogDebug(COMPONENT_FSAL, "fsal acl = %p, fsal_acl_status = %u", pacl, status); 00610 00611 if(pacl == NULL) 00612 { 00613 LogCrit(COMPONENT_FSAL, "gpfs_acl_2_fsal_acl: failed to create a new acl entry"); 00614 return ERR_FSAL_FAULT; 00615 } 00616 00617 /* Add fsal acl to attribute. */ 00618 p_object_attributes->acl = pacl; 00619 00620 return ERR_FSAL_NO_ERROR; 00621 } 00622 00623 /* Covert FSAL ACLs to GPFS NFS4 ACLs. */ 00624 fsal_status_t fsal_acl_2_gpfs_acl(fsal_acl_t *p_fsalacl, gpfsfsal_xstat_t *p_buffxstat) 00625 { 00626 int i; 00627 fsal_ace_t *pace; 00628 gpfs_acl_t *p_gpfsacl; 00629 00630 p_gpfsacl = (gpfs_acl_t *) p_buffxstat->buffacl; 00631 00632 p_gpfsacl->acl_level = 0; 00633 p_gpfsacl->acl_version = GPFS_ACL_VERSION_NFS4; 00634 p_gpfsacl->acl_type = GPFS_ACL_TYPE_NFS4; 00635 p_gpfsacl->acl_nace = p_fsalacl->naces; 00636 p_gpfsacl->acl_len = ((int)(signed long)&(((gpfs_acl_t *) 0)->ace_v1)) + p_gpfsacl->acl_nace * sizeof(gpfs_ace_v4_t); 00637 00638 for(pace = p_fsalacl->aces, i = 0; pace < p_fsalacl->aces + p_fsalacl->naces; pace++, i++) 00639 { 00640 p_gpfsacl->ace_v4[i].aceType = pace->type; 00641 p_gpfsacl->ace_v4[i].aceFlags = pace->flag; 00642 p_gpfsacl->ace_v4[i].aceIFlags = pace->iflag; 00643 p_gpfsacl->ace_v4[i].aceMask = pace->perm; 00644 00645 if(IS_FSAL_ACE_SPECIAL_ID(*pace)) 00646 p_gpfsacl->ace_v4[i].aceWho = pace->who.uid; 00647 else 00648 { 00649 if(IS_FSAL_ACE_GROUP_ID(*pace)) 00650 p_gpfsacl->ace_v4[i].aceWho = pace->who.gid; 00651 else 00652 p_gpfsacl->ace_v4[i].aceWho = pace->who.uid; 00653 } 00654 00655 LogDebug(COMPONENT_FSAL, "fsal_acl_2_gpfs_acl: gpfs ace: type = 0x%x, flag = 0x%x, perm = 0x%x, special = %d, %s = 0x%x", 00656 p_gpfsacl->ace_v4[i].aceType, p_gpfsacl->ace_v4[i].aceFlags, p_gpfsacl->ace_v4[i].aceMask, 00657 (p_gpfsacl->ace_v4[i].aceIFlags & FSAL_ACE_IFLAG_SPECIAL_ID) ? 1 : 0, 00658 (p_gpfsacl->ace_v4[i].aceFlags & FSAL_ACE_FLAG_GROUP_ID) ? "gid" : "uid", 00659 p_gpfsacl->ace_v4[i].aceWho); 00660 00661 } 00662 00663 ReturnCode(ERR_FSAL_NO_ERROR, 0); 00664 } 00665 00666 fsal_status_t fsal_cred_2_gpfs_cred(struct user_credentials *p_fsalcred, 00667 struct xstat_cred_t *p_gpfscred) 00668 { 00669 int i; 00670 00671 if(!p_fsalcred || !p_gpfscred) 00672 ReturnCode(ERR_FSAL_FAULT, 0); 00673 00674 p_gpfscred->principal = p_fsalcred->user; 00675 p_gpfscred->group = p_fsalcred->group; 00676 p_gpfscred->num_groups = p_fsalcred->nbgroups; 00677 00678 for(i = 0; i < p_fsalcred->nbgroups; i++) 00679 { 00680 p_gpfscred->eGroups[i] = p_fsalcred->alt_groups[i]; 00681 } 00682 00683 ReturnCode(ERR_FSAL_NO_ERROR, 0); 00684 } 00685 00686 fsal_status_t fsal_mode_2_gpfs_mode(fsal_accessmode_t fsal_mode, 00687 fsal_accessflags_t v4mask, 00688 unsigned int *p_gpfsmode, 00689 fsal_boolean_t is_dir) 00690 { 00691 int gpfs_mode = 0; 00692 00693 if(!p_gpfsmode) 00694 ReturnCode(ERR_FSAL_FAULT, 0); 00695 00696 /* If mode is zero, translate v4mask to posix mode. */ 00697 if(fsal_mode == 0) 00698 { 00699 if(!is_dir) 00700 { 00701 if(v4mask & FSAL_ACE_PERM_READ_DATA) 00702 gpfs_mode |= FSAL_R_OK; 00703 } 00704 else 00705 { 00706 if(v4mask & FSAL_ACE_PERM_LIST_DIR) 00707 { 00708 gpfs_mode |= FSAL_R_OK; 00709 gpfs_mode |= FSAL_X_OK; 00710 } 00711 } 00712 00713 if(!is_dir) 00714 { 00715 if(v4mask & FSAL_ACE_PERM_WRITE_DATA) 00716 gpfs_mode |= FSAL_W_OK; 00717 } 00718 else 00719 { 00720 if(v4mask & FSAL_ACE_PERM_ADD_FILE) 00721 { 00722 gpfs_mode |= FSAL_W_OK; 00723 gpfs_mode |= FSAL_X_OK; 00724 } 00725 } 00726 00727 if(!is_dir) 00728 { 00729 if(v4mask & FSAL_ACE_PERM_APPEND_DATA) 00730 gpfs_mode |= FSAL_W_OK; 00731 } 00732 else 00733 { 00734 if(v4mask & FSAL_ACE_PERM_ADD_SUBDIRECTORY) 00735 { 00736 gpfs_mode |= FSAL_W_OK; 00737 gpfs_mode |= FSAL_X_OK; 00738 } 00739 } 00740 00741 #if 0 00742 if(v4mask & FSAL_ACE_PERM_READ_NAMED_ATTR) 00743 gpfs_mode |= FSAL_R_OK; 00744 00745 if(v4mask & FSAL_ACE_PERM_WRITE_NAMED_ATTR) 00746 gpfs_mode |= FSAL_W_OK; 00747 #endif 00748 00749 if(!is_dir) 00750 { 00751 if(v4mask & FSAL_ACE_PERM_EXECUTE) 00752 gpfs_mode |= FSAL_X_OK; 00753 } 00754 else 00755 { 00756 if(v4mask & FSAL_ACE_PERM_DELETE_CHILD) 00757 { 00758 gpfs_mode |= FSAL_W_OK; 00759 gpfs_mode |= FSAL_X_OK; 00760 } 00761 } 00762 00763 #if 0 00764 if(v4mask & FSAL_ACE_PERM_READ_ATTR) 00765 gpfs_mode |= FSAL_R_OK; 00766 00767 if(v4mask & FSAL_ACE_PERM_WRITE_ATTR) 00768 gpfs_mode |= FSAL_W_OK; 00769 #endif 00770 00771 if(v4mask & FSAL_ACE_PERM_DELETE) 00772 gpfs_mode |= FSAL_W_OK; 00773 00774 #if 0 00775 if(v4mask & FSAL_ACE_PERM_READ_ACL) 00776 gpfs_mode |= FSAL_R_OK; 00777 00778 if(v4mask & FSAL_ACE_PERM_WRITE_ACL) 00779 gpfs_mode |= FSAL_W_OK; 00780 00781 if(v4mask & FSAL_ACE_PERM_WRITE_OWNER) 00782 gpfs_mode |= FSAL_W_OK; 00783 #endif 00784 00785 gpfs_mode = gpfs_mode >> 24; 00786 } 00787 else 00788 { 00789 gpfs_mode = fsal_mode >> 24; 00790 } 00791 00792 LogDebug(COMPONENT_FSAL, 00793 "fsal_mode 0x%x, v4mask 0x%x, is_dir %d converted to gpfs_mode 0x%x", 00794 fsal_mode, v4mask, is_dir, gpfs_mode); 00795 00796 *p_gpfsmode = gpfs_mode; 00797 00798 ReturnCode(ERR_FSAL_NO_ERROR, 0); 00799 } 00800 #endif /* _USE_NFS4_ACL */
1.7.3