X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Futils%2Fmount_utils_ldiskfs.c;h=dfb9e6cba750a2a5a20e2d28d7814612522ab3a4;hb=beb5686423e7a4d630ead4a3d2d4de75a3dc6e1c;hp=4c75200e73c7bbc1a6103beb2098692b47c86a81;hpb=aeb887ab0d4b15d17f3b96bf0e7be3b746edcf8e;p=fs%2Flustre-release.git diff --git a/lustre/utils/mount_utils_ldiskfs.c b/lustre/utils/mount_utils_ldiskfs.c index 4c75200..dfb9e6c 100644 --- a/lustre/utils/mount_utils_ldiskfs.c +++ b/lustre/utils/mount_utils_ldiskfs.c @@ -386,7 +386,7 @@ static int is_e2fsprogs_feature_supp(const char *feature) } ret = fread(supp_features, 1, sizeof(supp_features) - 1, fp); supp_features[ret] = '\0'; - fclose(fp); + pclose(fp); } if (ret > 0 && strstr(supp_features, strncmp(feature, "-O ", 3) ? feature : feature+3)) @@ -492,7 +492,7 @@ static int enable_default_ext4_features(struct mkfs_opts *mop, char *anchor, append_unique(anchor, ",", "huge_file", NULL, maxbuflen); /* Enable large block addresses if the LUN is over 2^32 blocks. */ - if (mop->mo_device_sz / (L_BLOCK_SIZE >> 10) >= 0x100002000ULL && + if (mop->mo_device_kb / (L_BLOCK_SIZE >> 10) >= 0x100002000ULL && is_e2fsprogs_feature_supp("-O 64bit") == 0) append_unique(anchor, ",", "64bit", NULL, maxbuflen); @@ -556,7 +556,7 @@ static char *moveopts_to_end(char *start) /* Build fs according to type */ int ldiskfs_make_lustre(struct mkfs_opts *mop) { - __u64 device_sz = mop->mo_device_sz, block_count = 0; + __u64 device_kb = mop->mo_device_kb, block_count = 0; char mkfs_cmd[PATH_MAX]; char buf[64]; char *start; @@ -565,26 +565,26 @@ int ldiskfs_make_lustre(struct mkfs_opts *mop) size_t maxbuflen; if (!(mop->mo_flags & MO_IS_LOOP)) { - mop->mo_device_sz = get_device_size(mop->mo_device); + mop->mo_device_kb = get_device_size(mop->mo_device); - if (mop->mo_device_sz == 0) + if (mop->mo_device_kb == 0) return ENODEV; /* Compare to real size */ - if (device_sz == 0 || device_sz > mop->mo_device_sz) - device_sz = mop->mo_device_sz; + if (device_kb == 0 || device_kb > mop->mo_device_kb) + device_kb = mop->mo_device_kb; else - mop->mo_device_sz = device_sz; + mop->mo_device_kb = device_kb; } - if (mop->mo_device_sz != 0) { - if (mop->mo_device_sz < 8096){ + if (mop->mo_device_kb != 0) { + if (mop->mo_device_kb < 8096) { fprintf(stderr, "%s: size of filesystem must be larger " "than 8MB, but is set to %lldKB\n", - progname, (long long)mop->mo_device_sz); + progname, (long long)mop->mo_device_kb); return EINVAL; } - block_count = mop->mo_device_sz / (L_BLOCK_SIZE >> 10); + block_count = mop->mo_device_kb / (L_BLOCK_SIZE >> 10); /* If the LUN size is just over 2^32 blocks, limit the * filesystem size to 2^32-1 blocks to avoid problems with * ldiskfs/mkfs not handling this size. Bug 22906 */ @@ -598,20 +598,27 @@ int ldiskfs_make_lustre(struct mkfs_opts *mop) long inode_size = 0; /* Journal size in MB */ - if (strstr(mop->mo_mkfsopts, "-J") == NULL) { + if (strstr(mop->mo_mkfsopts, "-J") == NULL && + device_kb > 1024 * 1024) { /* Choose our own default journal size */ - long journal_sz = 0, max_sz; - if (device_sz > 1024 * 1024) /* 1GB */ - journal_sz = (device_sz / 102400) * 4; - /* cap journal size at 1GB */ - if (journal_sz > 1024L) - journal_sz = 1024L; - /* man mkfs.ext3 */ - max_sz = (102400 * L_BLOCK_SIZE) >> 20; /* 400MB */ - if (journal_sz > max_sz) - journal_sz = max_sz; - if (journal_sz) { - sprintf(buf, " -J size=%ld", journal_sz); + long journal_mb = 0, max_mb; + + /* cap journal size at 4GB for MDT, + * leave it at 400MB for OSTs. */ + if (IS_MDT(&mop->mo_ldd)) + max_mb = 4096; + else if (IS_OST(&mop->mo_ldd)) + max_mb = 400; + else /* Use mke2fs default size for MGS */ + max_mb = 0; + + /* Use at most 4% of device for journal */ + journal_mb = device_kb * 4 / (1024 * 100); + if (journal_mb > max_mb) + journal_mb = max_mb; + + if (journal_mb) { + sprintf(buf, " -J size=%ld", journal_mb); strscat(mop->mo_mkfsopts, buf, sizeof(mop->mo_mkfsopts)); } @@ -669,18 +676,18 @@ int ldiskfs_make_lustre(struct mkfs_opts *mop) * this, but it is impossible to know in advance. */ if (IS_OST(&mop->mo_ldd)) { /* OST > 16TB assume average file size 1MB */ - if (device_sz > (16ULL << 30)) + if (device_kb > (16ULL << 30)) bytes_per_inode = 1024 * 1024; /* OST > 4TB assume average file size 512kB */ - else if (device_sz > (4ULL << 30)) + else if (device_kb > (4ULL << 30)) bytes_per_inode = 512 * 1024; /* OST > 1TB assume average file size 256kB */ - else if (device_sz > (1ULL << 30)) + else if (device_kb > (1ULL << 30)) bytes_per_inode = 256 * 1024; /* OST > 10GB assume average file size 64kB, * plus a bit so that inodes will fit into a * 256x flex_bg without overflowing */ - else if (device_sz > (10ULL << 20)) + else if (device_kb > (10ULL << 20)) bytes_per_inode = 69905; } @@ -741,8 +748,8 @@ int ldiskfs_make_lustre(struct mkfs_opts *mop) * descriptor blocks, but leave one block for the superblock. * Only useful for filesystems with < 2^32 blocks due to resize * limitations. */ - if (IS_OST(&mop->mo_ldd) && mop->mo_device_sz > 100 * 1024 && - mop->mo_device_sz * 1024 / L_BLOCK_SIZE <= 0xffffffffULL) { + if (IS_OST(&mop->mo_ldd) && mop->mo_device_kb > 100 * 1024 && + mop->mo_device_kb * 1024 / L_BLOCK_SIZE <= 0xffffffffULL) { unsigned group_blocks = L_BLOCK_SIZE * 8; unsigned desc_per_block = L_BLOCK_SIZE / 32; unsigned resize_blks; @@ -1130,9 +1137,17 @@ static char *absolute_path(char *devname) return NULL; } strcat(buf, "/"); - strcat(buf, devname); + if (strlen(devname) > sizeof(buf)-strlen(buf)-1) { + free(path); + return NULL; + } + strncat(buf, devname, sizeof(buf)-strlen(buf)-1); } else { - strcpy(buf, devname); + if (strlen(devname) > sizeof(buf)-1) { + free(path); + return NULL; + } + strncpy(buf, devname, sizeof(buf)); } /* truncate filename before calling realpath */ ptr = strrchr(buf, '/'); @@ -1209,7 +1224,7 @@ static int is_feature_enabled(const char *feature, const char *devpath) ret = fread(enabled_features, 1, sizeof(enabled_features) - 1, fp); enabled_features[ret] = '\0'; - fclose(fp); + pclose(fp); if (strstr(enabled_features, feature)) return 1;