}
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))
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);
/* 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;
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 */
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));
}
* 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;
}
* 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;
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;