From: nathan Date: Sat, 23 Jul 2005 01:28:54 +0000 (+0000) Subject: Branch b1_4_newconfig2 X-Git-Tag: v1_8_0_110~486^4~175^2~36 X-Git-Url: https://git.whamcloud.com/gitweb?a=commitdiff_plain;h=ee865231136e82995c2b34943fe89fe490df2564;p=fs%2Flustre-release.git Branch b1_4_newconfig2 b=6663 continued mkfs refinement --- diff --git a/lustre/include/linux/lustre_disk.h b/lustre/include/linux/lustre_disk.h index a94c63b..e10ed4a 100644 --- a/lustre/include/linux/lustre_disk.h +++ b/lustre/include/linux/lustre_disk.h @@ -28,6 +28,7 @@ #define _LUSTRE_DISK_H #include +#include /****************** last_rcvd file *********************/ @@ -67,7 +68,7 @@ struct host_desc { struct lustre_mount_data { __u32 lmd_magic; __u32 lmd_flags; /* lustre mount flags */ - host_desc lmd_mgmt; /* mgmt nid */ + struct host_desc lmd_mgmtnid; /* mgmt nid */ char lmd_dev[128]; /* device or file system name */ char lmd_mtpt[128]; /* mount point (for client overmount) */ char lmd_opts[256]; /* lustre mount options (as opposed to @@ -78,8 +79,8 @@ struct lustre_mount_data { #define LMD_FLG_MNTCNF 0x1000 /* MountConf compat */ #define LMD_FLG_CLIENT 0x2000 /* Mounting a client only; no real device */ -#define lmd_is_client(x) \ - ((x->lmd_flags & LMD_FLG_CLIENT) || (!(x->lmd_flags & LMD_FLG_MNTCNF)) +#define lmd_is_client(x) \ + (((x)->lmd_flags & LMD_FLG_CLIENT) || (!((x)->lmd_flags & LMD_FLG_MNTCNF))) /****************** persistent mount data *********************/ @@ -102,7 +103,7 @@ struct lustre_mount_data { struct lustre_disk_data { __u32 ldd_magic; __u32 ldd_flags; - host_desc ldd_mgmt; /* mgmt nid; lmd can override */ + struct host_desc ldd_mgmtnid; /* mgmt nid; lmd can override */ char ldd_fsname[64]; /* filesystem this server is part of */ char ldd_svname[64]; /* this server's name (lustre-mdt0001) */ __u8 ldd_mount_type; /* target fs type LDD_FS_TYPE_* */ @@ -116,23 +117,27 @@ struct lustre_disk_data { /****************** mkfs command *********************/ -#define MO_IS_LOOP 0x01 +#define MO_IS_LOOP 0x01 +#define MO_FORCEFORMAT 0x02 /* used to describe the options to format the lustre disk, not persistent */ struct mkfs_opts { struct lustre_disk_data mo_ldd; /* to be written in MOUNT_DATA_FILE */ - long mo_device_sz; - int mo_flags; char mo_mount_type_string[20]; /* "ext3", "ldiskfs", ... */ char mo_device[128]; /* disk device name */ char mo_mkfsopts[128]; /* options to the backing-store mkfs */ - ptl_nid_t mo_failover_nid; + long mo_device_sz; + int mo_flags; + /* Below here is required for mdt,ost,or client logs */ + struct host_desc mo_hostnid; /* server nid + failover - need to know + for client log */ int mo_stripe_sz; int mo_stripe_count; int mo_stripe_pattern; int mo_index; /* stripe index for osts, pool index for pooled mdts. index will be put in lr_server_data */ + int mo_timeout; /* obd timeout */ }; diff --git a/lustre/utils/mkfs_lustre.c b/lustre/utils/mkfs_lustre.c index 1a9969f..8160809 100644 --- a/lustre/utils/mkfs_lustre.c +++ b/lustre/utils/mkfs_lustre.c @@ -38,9 +38,8 @@ #include #include - -#include "obdctl.h" #include +#include "obdctl.h" /* So obd.o will link */ #include "parser.h" @@ -83,8 +82,9 @@ void usage(FILE *out) "\t\t--stripe_count=#N:number of stripe\n" "\t\t--stripe_size=#N(KB):stripe size\n" "\t\t--index=#N:target index\n" - "\t\t--smfsopts \n" - "\t\t--ext3opts \n" + "\t\t--mountopts=: permanent mount options\n" + "\t\t--smfsopts=: smfs format options\n" + "\t\t--ext3opts=: ext3 format options\n" "\t\t--timeout=: system timeout period\n" "\t\t--maxwait=: time to wait for other servers to join\n" "\t\t--forceformat: overwrite an existing disk\n" @@ -269,6 +269,7 @@ int write_local_files(struct mkfs_opts *mop) struct lr_server_data lsd; char mntpt[] = "/tmp/mntXXXXXX"; char filepnm[sizeof(mntpt) + 15]; + char local_mount_opts[sizeof(mop->mo_ldd.ldd_mount_opts)] = ""; FILE *filep; int ret = 0; @@ -279,10 +280,15 @@ int write_local_files(struct mkfs_opts *mop) return errno; } - if (mop->mo_flags & MO_IS_LOOP) - sprintf(cmd, "mount -o loop %s %s", mop->mo_device, mntpt); - else - sprintf(cmd, "mount -t ext3 %s %s", mop->mo_device, mntpt); + if (mop->mo_flags & MO_IS_LOOP) { + if (strlen(mop->mo_ldd.ldd_mount_opts)) + snprintf(local_mount_opts, sizeof(local_mount_opts), + "loop,%s", mop->mo_ldd.ldd_mount_opts); + else sprintf(local_mount_opts, "loop"); + } + sprintf(cmd, "mount -t ext3 %s%s %s %s", + strlen(local_mount_opts) ? "-o ": "", + local_mount_opts, mop->mo_device, mntpt); ret = run_command(cmd, cmd_out); if (ret) { fprintf(stderr, "Unable to mount %s\n", mop->mo_device); @@ -327,7 +333,7 @@ out_rmdir: /* Build fs according to type */ int make_lustre_backfs(struct mkfs_opts *mop) { - int i,ret=0; + int i, ret = 0; int block_count = 0; char mkfs_cmd[256]; char buf[40]; @@ -342,8 +348,8 @@ int make_lustre_backfs(struct mkfs_opts *mop) block_count = mop->mo_device_sz / 4; /* block size is 4096 */ } - if ((mop->ldd.ldd_fs_type == LDD_FS_TYPE_EXT3) || - (mop->ldd.ldd_fs_type == LDD_FS_TYPE_LDISKFS)) { + if ((mop->mo_ldd.ldd_mount_type == LDD_FS_TYPE_EXT3) || + (mop->mo_ldd.ldd_mount_type == LDD_FS_TYPE_LDISKFS)) { long device_sz = mop->mo_device_sz; /* we really need the size */ @@ -356,7 +362,7 @@ int make_lustre_backfs(struct mkfs_opts *mop) device_sz = device_size_proc(mop->mo_device); } - if (strstr(mop->mo_mkfsopts, "-J" == NULL) { + if (strstr(mop->mo_mkfsopts, "-J") == NULL) { long journal_sz = 0; if (device_sz > 1024 * 1024) journal_sz = (device_sz / 102400) * 4; @@ -368,7 +374,7 @@ int make_lustre_backfs(struct mkfs_opts *mop) } } - if (strstr(mop->mo_mkfsopts, "-i" == NULL) { + if (strstr(mop->mo_mkfsopts, "-i") == NULL) { long inode_sz = 0; /* The larger the bytes-per-inode ratio, the fewer @@ -377,30 +383,30 @@ int make_lustre_backfs(struct mkfs_opts *mop) inode_sz = 4096; else if (mop->mo_stripe_count > 35) inode_sz = 2048; - else if (IS_MDT(mop->mo_ldd)) + else if (IS_MDT(&mop->mo_ldd)) inode_sz = 1024; - else if ((IS_OST(mop->mo_ldd) && (device_sz > 1000000) + else if ((IS_OST(&mop->mo_ldd) && (device_sz > 1000000))) inode_sz = 16384; if (inode_sz > 0) { sprintf(buf, " -i %d", inode_sz); - strcat(mop->mkfsopts, buf); + strcat(mop->mo_mkfsopts, buf); } } sprintf(mkfs_cmd, "mkfs.ext2 -j -b 4096 -L %s ", mop->mo_ldd.ldd_svname); - } else if (mop->ldd.ldd_fs_type == LDD_FS_TYPE_REISERFS) { + } else if (mop->mo_ldd.ldd_mount_type == LDD_FS_TYPE_REISERFS) { long journal_sz = 0; if (journal_sz > 0) { /* FIXME */ sprintf(buf, " --journal_size %d", journal_sz); - strcat(mop->mkfsopts, buf); + strcat(mop->mo_mkfsopts, buf); } sprintf(mkfs_cmd, "mkreiserfs -ff "); } else { fprintf(stderr,"unsupported fs type: %s\n", - mop->fs_type_string); + mop->mo_mount_type_string); return EINVAL; } @@ -433,13 +439,13 @@ int make_lustre_backfs(struct mkfs_opts *mop) /* Enable hashed b-tree directory lookup in large dirs FIXME MDT only? */ - if ((mop->ldd.ldd_fs_type == LDD_FS_TYPE_EXT3) || - (mop->ldd.ldd_fs_type == LDD_FS_TYPE_LDISKFS)) { + if ((mop->mo_ldd.ldd_mount_type == LDD_FS_TYPE_EXT3) || + (mop->mo_ldd.ldd_mount_type == LDD_FS_TYPE_LDISKFS)) { sprintf(cmd, "tune2fs -O dir_index %s", mop->mo_device); ret = run_command(cmd, cmd_out); if (ret) { fprintf(stderr,"Unable to enable htree: %s\n", - mop->device); + mop->mo_device); exit(4); } } @@ -476,6 +482,7 @@ int create_loop_device(struct mkfs_opts *mop) static int jt_setup() { int ret; + /* FIXME uneeded? */ ret = access("/dev/portals", F_OK); if (ret) system("mknod /dev/portals c 10 240"); @@ -484,11 +491,7 @@ static int jt_setup() system("mknod /dev/obd c 10 241"); ptl_initialize(0, NULL); - ret = obd_initialize(0, NULL); - if (ret) { - fprintf(stderr,"Can't obd initialize\n"); - return 2; - } + obd_initialize(0, NULL); return 0; } @@ -542,39 +545,46 @@ static int _do_jt(int (*cmd)(int argc, char **argv), char *cmd_name, ...) int lustre_log_setup(struct mkfs_opts *mop) { - char confname[] = "confobd"; + char confname[] = "llog_writer"; char name[128]; int ret = 0; vprint("Creating Lustre logs\n"); - if (jt_setup()) - return 2; + if ((ret = jt_setup())) + return ret; - /* Set up our confobd for writing logs */ - ret = do_jt_noret(jt_lcfg_attach, "attach", "confobd", confname, + /* FIXME can't we just write these log files ourselves? Why do we + have to go through an obd at all? */ + /* FIXME use mgmt server obd to write logs. Can start it by mounting + I think. */ + /* Set up a temporary obd for writing logs. + mds and confobd can handle OBD_IOC_DORECORD */ + ret = do_jt_noret(jt_lcfg_attach, "attach", "mds"/*confobd*/, confname, "conf_uuid", 0); if (ret) return ENODEV; ret = do_jt_noret(jt_lcfg_device, "cfg_device", confname, 0); if (ret) return ENODEV; - do_jt(jt_lcfg_setup, "setup", mop->device, mop->fs_type_string, - mop->mountfsopts, 0); - do_jt(jt_obd_device, "device", "confobd", 0); + do_jt(jt_lcfg_setup, "setup", mop->mo_device, + mop->mo_mount_type_string, mop->mo_ldd.ldd_mount_opts, 0); + /* Record on this device. */ + do_jt(jt_obd_device, "device", confname, 0); - sprintf(name, "%s-conf", mop->mo_ldd.ldd_svname); + snprintf(name, sizeof(name), "%s-conf", mop->mo_ldd.ldd_svname); - if (IS_OST(mop->mo_ldd)) { + if (IS_OST(&mop->mo_ldd)) { do_jt(jt_cfg_clear_log, "clear_log", name, 0); do_jt(jt_cfg_record, "record", name, 0); - do_jt(jt_lcfg_attach, "attach", "obdfilter", + do_jt(jt_lcfg_attach, "attach", "obdfilter", mop->mo_ldd.ldd_svname, mop->mo_ldd.ldd_svname/*uuid*/, 0); - do_jt(jt_lcfg_device, "cfg_device", mop->mo_ldd.ldd_svname, 0); - do_jt(jt_lcfg_setup, "setup", mop->mo_device, + do_jt(jt_lcfg_device, "cfg_device", mop->mo_ldd.ldd_svname, 0); + /* FIXME setup needs to change - no disk info */ + do_jt(jt_lcfg_setup, "setup", mop->mo_device, mop->mo_mount_type_string, "f", /* f=recovery enabled, n=disabled */ - mop->mo_ldd.ldd_mountopts, 0); + mop->mo_ldd.ldd_mount_opts, 0); do_jt(jt_cfg_endrecord, "endrecord", 0); do_jt(jt_cfg_dump_log, "dump_log", name, 0); @@ -583,11 +593,15 @@ int lustre_log_setup(struct mkfs_opts *mop) do_jt(jt_lcfg_attach, "attach", "ost", "OSS", "OSS_UUID", 0); do_jt(jt_lcfg_device, "cfg_device", "OSS", 0); do_jt(jt_lcfg_setup, "setup", 0); + if (mop->mo_timeout) + do_jt(jt_lcfg_set_timeout, "set_timeout", + mop->mo_timeout, 0); do_jt(jt_cfg_endrecord, "endrecord", 0); } - - if (IS_MDT(mop->mo_ldd)) { + + if (IS_MDT(&mop->mo_ldd)) { char scnt[20], ssz[20], soff[20], spat[20]; + char cliname[sizeof(mop->mo_ldd.ldd_fsname)]; /* Write mds-conf log */ do_jt(jt_cfg_clear_log, "clear_log", name, 0); @@ -596,13 +610,16 @@ int lustre_log_setup(struct mkfs_opts *mop) do_jt(jt_lcfg_device, "cfg_device", "MDT", 0); do_jt(jt_lcfg_setup, "setup", 0); do_jt(jt_lcfg_attach, "attach", "mds", mop->mo_ldd.ldd_svname, - mop->obduuid, 0); + mop->mo_ldd.ldd_svname/*uuid*/, 0); do_jt(jt_lcfg_device, "cfg_device", mop->mo_ldd.ldd_svname, 0); do_jt(jt_lcfg_setup, "setup", mop->mo_device, - mop->fs_type_string, - mop->mo_ldd.ldd_svname, mop->mountfsopts, 0); + mop->mo_mount_type_string, mop->mo_ldd.ldd_svname, + mop->mo_ldd.ldd_mount_opts, 0); + if (mop->mo_timeout) + do_jt(jt_lcfg_set_timeout, "set_timeout", + mop->mo_timeout, 0); do_jt(jt_cfg_endrecord, "endrecord", 0); - + /* Write mds startup log */ do_jt(jt_cfg_clear_log, "clear_log", mop->mo_ldd.ldd_svname, 0); do_jt(jt_cfg_record, "record", mop->mo_ldd.ldd_svname, 0); @@ -610,7 +627,7 @@ int lustre_log_setup(struct mkfs_opts *mop) lov_setup lovA_UUID 0 1048576 0 0 ost1_UUID mount_option mdsA lov_conf_mdsA */ - sprintf(name, "lov-%s", mop->mo_ldd.ldd_svname); + snprintf(name, sizeof(name), "lov-%s", mop->mo_ldd.ldd_svname); do_jt(jt_lcfg_attach, "attach", "lov", name, name/*uuid*/, 0); snprintf(scnt, sizeof(scnt), "%d", mop->mo_stripe_count); @@ -631,14 +648,20 @@ int lustre_log_setup(struct mkfs_opts *mop) mds_postsetup calls class_get_profile to lookup the lov name: (profile=mds,osc=lov,mdc=0); This command was originally intended for clients: - class_add_profile(profile,osc,mdc) */ + class_add_profile(profile,osc,mdc). + FIXME if we always make lovname=f(mdsname), we probably + don't need this. */ do_jt(jt_lcfg_mount_option, "mount_option", - mop->mo_ldd.ldd_svname, name, 0); + mop->mo_ldd.ldd_svname/*mds*/, name/*lov*/, 0); + if (mop->mo_timeout) + do_jt(jt_lcfg_set_timeout, "set_timeout", + mop->mo_timeout, 0); do_jt(jt_cfg_endrecord, "endrecord", 0); + /* Write client startup log */ do_jt(jt_cfg_clear_log, "clear_log", "client", 0); - do_jt(jt_cfg_record, "record", "client, 0); + do_jt(jt_cfg_record, "record", "client", 0); do_jt(jt_lcfg_attach, "attach", "lov", name, name/*uuid*/, 0); do_jt(jt_lcfg_lov_setup, "lov_setup", name/*uuid*/, @@ -651,15 +674,29 @@ int lustre_log_setup(struct mkfs_opts *mop) #12 L add_uuid nid=c0a80202 nal_type=0 0:(null) 1:NID_uml2_UUID #13 L add_conn 0:MDC_uml1_mdsA_MNT_client 1:NID_uml2_UUID */ - do_jt(jt_lcfg_add_uuid, "add_uuid", uuid=mdshostname, + //FIXME use gethostname for nid uuid? + do_jt(jt_lcfg_add_uuid, "add_uuid", + libcfs_nid2str(mop->mo_hostnid.primary), mop->mo_hostnid.primary, 0); - do_jt(jt_lcfg_add_uuid, "add_uuid", uuid, - mop->mo_hostnid.secondary, 0); - + snprintf(cliname, sizeof(cliname), "%s-mdc", + mop->mo_ldd.ldd_fsname); + do_jt(jt_lcfg_attach, "attach", "mdc", cliname, + cliname/*uuid*/, 0); + do_jt(jt_lcfg_device, "cfg_device", cliname, 0); + do_jt(jt_lcfg_setup, "setup", mop->mo_ldd.ldd_svname, + libcfs_nid2str(mop->mo_hostnid.primary), 0); + if (mop->mo_hostnid.backup != PTL_NID_ANY) { + do_jt(jt_lcfg_add_uuid, "add_uuid", + libcfs_nid2str(mop->mo_hostnid.backup), + mop->mo_hostnid.backup, 0); + do_jt(jt_lcfg_add_conn, "add_conn", + libcfs_nid2str(mop->mo_hostnid.backup)/*uuid*/, 0); + } do_jt(jt_lcfg_mount_option, "mount_option", - "client", name, mdcname, 0); - - + "client", name/*osc(lov)*/, cliname, 0); + if (mop->mo_timeout) + do_jt(jt_lcfg_set_timeout, "set_timeout", + mop->mo_timeout, 0); } out: @@ -671,7 +708,7 @@ out: do_jt_noret(jt_obd_cleanup, "cleanup", 0); do_jt_noret(jt_obd_detach, "detach", 0); - do_jt_noret(obd_finalize, "finalize", 0); + obd_finalize(1, (char **)&name /*dummy*/); return ret; } @@ -700,12 +737,12 @@ static void make_sv_name(struct mkfs_opts *mop) So rewrite ost log, last_rcvd, and disk label, or we need to talk to MGMT now to get index # */ - if (IS_MGMT(mop->mo_ldd)) { + if (IS_MGMT(&mop->mo_ldd)) { sprintf(mop->mo_ldd.ldd_svname, "MGMT"); } else { sprintf(mop->mo_ldd.ldd_svname, "%.8s-%s%04x", mop->mo_ldd.ldd_fsname, - IS_MDT(mop->mo_ldd) ? "MDT" : "OST", + IS_MDT(&mop->mo_ldd) ? "MDT" : "OST", mop->mo_index); } vprint("Server name: %s\n", mop->mo_ldd.ldd_svname); @@ -713,18 +750,22 @@ static void make_sv_name(struct mkfs_opts *mop) void set_defaults(struct mkfs_opts *mop) { + char hostname[120]; mop->mo_ldd.ldd_magic = LDD_MAGIC; if (get_os_version() == 24) { - mop->ldd.ldd_fs_type = LDD_FS_TYPE_EXT3; - strcpy(mop->fs_type_string, "ext3"); + mop->mo_ldd.ldd_mount_type = LDD_FS_TYPE_EXT3; + strcpy(mop->mo_mount_type_string, "ext3"); } else { - mop->ldd.ldd_fs_type = LDD_FS_TYPE_LDISKFS; - strcpy(mop->fs_type_string, "ldiskfs"); + mop->mo_ldd.ldd_mount_type = LDD_FS_TYPE_LDISKFS; + strcpy(mop->mo_mount_type_string, "ldiskfs"); } strcpy(mop->mo_ldd.ldd_fsname, "lustre"); mop->mo_index = -1; + + gethostname(hostname, sizeof(hostname)); + mop->mo_hostnid.primary = libcfs_str2nid(hostname); } static inline badopt(char opt, char *type) @@ -751,6 +792,7 @@ int main(int argc , char *const argv[]) {"mdt", 0, 0, 'M'}, {"mgmt", 0, 0, 'G'}, {"mgmtnode", 1, 0, 'm'}, + {"mountopts", 1, 0, 'o'}, {"ost", 0, 0, 'O'}, {"smfsopts", 1, 0, 'S'}, {"stripe_count", 1, 0, 'c'}, @@ -760,8 +802,9 @@ int main(int argc , char *const argv[]) {"verbose", 0, 0, 'v'}, {0, 0, 0, 0} }; - char *optstring = "C:d:e:n:f:FhI:w:MGm:OS:c:s:i:t:v"; + char *optstring = "C:d:e:n:f:FhI:w:MGm:o:OS:c:s:i:t:v"; char opt; + char *mountopts = NULL; int ret = 0; progname = argv[0]; @@ -775,7 +818,7 @@ int main(int argc , char *const argv[]) switch (opt) { case 'C': //FIXME - exit 2; + exit(2); case 'c': if (IS_MDT(&mop.mo_ldd)) { int stripe_count = atol(optarg); @@ -788,15 +831,15 @@ int main(int argc , char *const argv[]) mop.mo_device_sz = atol(optarg); break; case 'e': - if ((mop.mo_ldd.ldd_fs_type == LDD_FS_TYPE_LDISKFS) || - (mop.mo_ldd.ldd_fs_type == LDD_FS_TYPE_EXT3)) - strncpy(mop.mkfsopts, optarg, - sizeof(mop.mkfsopts) - 1); + if ((mop.mo_ldd.ldd_mount_type == LDD_FS_TYPE_LDISKFS) || + (mop.mo_ldd.ldd_mount_type == LDD_FS_TYPE_EXT3)) + strncpy(mop.mo_mkfsopts, optarg, + sizeof(mop.mo_mkfsopts) - 1); else badopt(opt, "ext3,ldiskfs"); break; case 'f': - mop.mo_failover_nid = libcfs_str2nid(optarg); + mop.mo_hostnid.backup = libcfs_str2nid(optarg); break; case 'F': mop.mo_flags |= MO_FORCEFORMAT; @@ -816,7 +859,7 @@ int main(int argc , char *const argv[]) case 'm': if (IS_MGMT(&mop.mo_ldd)) badopt(opt, "non-MGMT MDT,OST"); - set_nid_pair(&mo.mo_ldd->ldd.mgmt, optarg); + set_nid_pair(&mop.mo_ldd.ldd_mgmtnid, optarg); break; case 'M': mop.mo_ldd.ldd_flags |= LDD_SV_TYPE_MDT; @@ -833,6 +876,9 @@ int main(int argc , char *const argv[]) strncpy(mop.mo_ldd.ldd_fsname, optarg, sizeof(mop.mo_ldd.ldd_fsname) - 1); break; + case 'o': + mountopts = optarg; + break; case 'O': mop.mo_ldd.ldd_flags |= LDD_SV_TYPE_OST; break; @@ -843,9 +889,12 @@ int main(int argc , char *const argv[]) badopt(opt, "MDT"); break; case 'S': - mop.mo_ldd.ldd_fs_type = LDD_FS_TYPE_SMFS; - strcpy(mop.fs_type_string, "smfs"); - strncpy(mop.mkfsopts, optarg, sizeof(mop.mkfsopts) - 1); + mop.mo_ldd.ldd_mount_type = LDD_FS_TYPE_SMFS; + strcpy(mop.mo_mount_type_string, "smfs"); + strncpy(mop.mo_mkfsopts, optarg, sizeof(mop.mo_mkfsopts) - 1); + break; + case 't': + mop.mo_timeout = atol(optarg); break; case 'v': verbose++; @@ -866,13 +915,13 @@ int main(int argc , char *const argv[]) } if (IS_MDT(&mop.mo_ldd) && !IS_MGMT(&mop.mo_ldd) && - mop.mo_ldd.ldd_mgmt.primary == PTL_NID_ANY) { + mop.mo_ldd.ldd_mgmtnid.primary == PTL_NID_ANY) { vprint("No MGMT specified, adding to this MDT\n"); mop.mo_ldd.ldd_flags |= LDD_SV_TYPE_MGMT; //FIXME mop.mo_ldd.ldd_mgmt.primary == libcfs_str2nid(localhost); } - if (mop.mo_ldd.ldd_mgmt.primary == PTL_NID_ANY) { + if (mop.mo_ldd.ldd_mgmtnid.primary == PTL_NID_ANY) { printf("Must specify either --mgmt or --mgmtnode\n"); usage(stderr); } @@ -883,28 +932,32 @@ int main(int argc , char *const argv[]) mop.mo_stripe_sz = 1024 * 1024; /* These are the permanent mount options. */ - if ((mop.mo_ldd.ldd_fs_type == LDD_FS_TYPE_EXT3) || - (mop.mo_ldd.ldd_fs_type == LDD_FS_TYPE_LDISKFS)) { - sprintf(mop.mo_ldd.ldd_mountfsopts, "errors=remount-ro"); + if ((mop.mo_ldd.ldd_mount_type == LDD_FS_TYPE_EXT3) || + (mop.mo_ldd.ldd_mount_type == LDD_FS_TYPE_LDISKFS)) { + sprintf(mop.mo_ldd.ldd_mount_opts, "errors=remount-ro"); if (IS_MDT(&mop.mo_ldd)) - strcat(mop.mo_ldd.ldd_mountfsopts, ",iopen_nopriv"); + strcat(mop.mo_ldd.ldd_mount_opts, ",iopen_nopriv"); if ((IS_OST(&mop.mo_ldd)) && (get_os_version() == 24)) - strcat(mmop.mo_ldd.ldd_mountfsopts, ",asyncdel"); - } else if (mop.mo_ldd.ldd_fs_type == LDD_FS_TYPE_SMFS) { - sprintf(mop.mo_ldd.ldd_mountfsopts, "type=ext3,dev=%s", + strcat(mop.mo_ldd.ldd_mount_opts, ",asyncdel"); + } else if (mop.mo_ldd.ldd_mount_type == LDD_FS_TYPE_SMFS) { + sprintf(mop.mo_ldd.ldd_mount_opts, "type=ext3,dev=%s", mop.mo_device); } else { fprintf(stderr, "%s: unknown fs type %d '%s'\n", - progname, mop.mo_ldd.ldd_fs_type, + progname, mop.mo_ldd.ldd_mount_type, mop.mo_mount_type_string); return EINVAL; } - + if (mountopts) { + strcat(mop.mo_ldd.ldd_mount_opts, ","); + strcat(mop.mo_ldd.ldd_mount_opts, mountopts); + } + make_sv_name(&mop); - if ((mop->mo_ldd.ldd_fs_type == LDD_FS_TYPE_SMFS) || - !is_block(mop.device)) { - mop.flags |= MO_IS_LOOP; + if ((mop.mo_ldd.ldd_mount_type == LDD_FS_TYPE_SMFS) || + !is_block(mop.mo_device)) { + mop.mo_flags |= MO_IS_LOOP; ret = create_loop_device(&mop); if (ret) return ret; diff --git a/lustre/utils/mount_lustre.c b/lustre/utils/mount_lustre.c index 5ae3c3b..dddbe86 100644 --- a/lustre/utils/mount_lustre.c +++ b/lustre/utils/mount_lustre.c @@ -35,9 +35,9 @@ #include #include -#include "obdctl.h" -#include #include +#include +#include "obdctl.h" int verbose; int nomtab; @@ -109,11 +109,9 @@ static int load_modules(struct lustre_mount_data *lmd) if (lmd_is_client(lmd)) { rc = load_module("lustre"); } else { - if (lmd->u.srv.disk_type & MDS_DISK_TYPE) - rc = load_module("mds"); + rc = load_module("mds"); if (rc) return rc; - if (lmd->u.srv.disk_type & OST_DISK_TYPE) - rc = load_module("oss"); + rc = load_module("oss"); } return rc; } @@ -189,16 +187,16 @@ init_options(struct lustre_mount_data *lmd) //ptl_parse_ipaddr(&lmd->lmd_ipaddr, lmd->lmd_hostname); lmd->lmd_magic = LMD_MAGIC; lmd->lmd_flags = LMD_FLG_MNTCNF; - lmd->lmd_mgmt.primary = PTL_NID_ANY; - lmd->lmd_mgmt.backup = PTL_NID_ANY; + lmd->lmd_mgmtnid.primary = PTL_NID_ANY; + lmd->lmd_mgmtnid.backup = PTL_NID_ANY; return 0; } int print_options(struct lustre_mount_data *lmd) { - printf("mgmt primary nid: %s\n", libcfs_nid2str(lmd->lmd_mgmt.primary); - printf("mgmt backup nid: %s\n", libcfs_nid2str(lmd->lmd_mgmt.backup); + printf("mgmt primary nid: %x\n", /*libcfs_nid2str*/(lmd->lmd_mgmtnid.primary)); + printf("mgmt backup nid: %x\n", /*libcfs_nid2str*/(lmd->lmd_mgmtnid.backup)); printf("device: %s\n", lmd->lmd_dev); printf("mount point: %s\n", lmd->lmd_mtpt); printf("options: %s\n", lmd->lmd_opts); @@ -292,64 +290,6 @@ int parse_options(char *options, struct lustre_mount_data *lmd, int *flagp) return 0; } -#if 0 -int read_mount_options(char *source, char *target, - struct lustre_mount_data *lmd) -{ - char cmd[512]; - char opfilenm[255]; - FILE *opfile; - __u32 lddmagic; - int ret; - - if ( strlen(lmd->u.srv.lmd_source) == 0) { - strcpy(lmd->u.srv.lmd_source, source); - sprintf(cmd, "mount -t ext3 %s %s", lmd->u.srv.lmd_source, target); - } - else - sprintf(cmd, "mount -o loop %s %s", lmd->u.srv.lmd_source, target); - - ret = system(cmd); - if (ret) { - fprintf(stderr, "Unable to mount %s\n", lmd->u.srv.lmd_source); - return errno; - } - - /* mounted, now read the options file */ - sprintf(opfilenm, "%s/%s", target, MOUNTOPTS_FILE_NAME); - opfile = fopen(opfilenm, "r"); - if (!opfile) { - fprintf(stderr,"Unable to open options file %s: %s\n", - opfilenm, strerror(errno)); - ret = errno; - goto out_umnt; - } - - ret = fscanf(opfile, "%x\n", &lddmagic); - if (ret < 1) { - fprintf(stderr, "Can't read options file %s\n", opfilenm); - goto out_close; - } - if (lddmagic != LDD_MAGIC) { - fprintf(stderr, "Bad magic in options file %s\n", opfilenm); - goto out_close; - } - - fscanf(opfile, "%s\n", lmd->u.srv.lmd_fstype); - fscanf(opfile, "%s\n", lmd->u.srv.lmd_fsopts); - fscanf(opfile, "%x\n", &lmd->u.srv.disk_type); - //fread(&data->mgt.host, sizeof(data->mgt.host), 1, opfile); - ret = 0; - -out_close: - fclose(opfile); -out_umnt: - sprintf(cmd, "umount %s", target); - system(cmd); - return ret; -} -#endif - int build_data(char *source, char *target, char *options, struct lustre_mount_data *lmd, int *flagp) @@ -380,17 +320,17 @@ build_data(char *source, char *target, char *options, nid=mgmtnid, devname=fsname */ nid = buf; *s = '\0'; - while (*++s == '/') ; + while (*++s == '/') /*spin*/; devname = s; rc = parse_options(options, lmd, flagp); if (rc) return rc; - if (lmd->lmd_nid != PTL_NID_ANY) + if (lmd->lmd_mgmtnid.primary != PTL_NID_ANY) /* In case it was defined as -o mgmtnode= */ - lmd->lmd_mgmt.primary = libcfs_str2nid(nid); - if (lmd->lmd_mgmt.primary == PTL_NID_ANY) { + //FIXME set_nid_pair(&lmd->lmd_mgmtnid, nid); + if (lmd->lmd_mgmtnid.primary == PTL_NID_ANY) { fprintf(stderr, "%s: can't parse nid '%s'\n", progname, nid); return 1;