From 81bd69941cc9ebd98a62d98e70d79463557fa7bd Mon Sep 17 00:00:00 2001 From: nathan Date: Wed, 27 Jul 2005 23:11:32 +0000 Subject: [PATCH] Branch b1_4_newconfig2 b=6663 ongoing toward DLD: lvfs_mount.c etc. --- lustre/include/linux/lustre_disk.h | 47 +++--- lustre/include/linux/lvfs.h | 8 + lustre/include/linux/obd.h | 35 +++-- lustre/include/lustre/lustre_user.h | 2 +- lustre/llite/llite_internal.h | 8 +- lustre/llite/llite_lib.c | 4 +- lustre/lvfs/lvfs_mount.c | 299 +++++++++++++++++++++++++----------- lustre/mds/handler.c | 4 + lustre/obdfilter/filter.c | 101 ++++++------ lustre/obdfilter/filter_internal.h | 26 +--- lustre/utils/Makefile.am | 38 +++-- lustre/utils/mkfs_lustre.c | 70 ++++----- lustre/utils/mount_lustre.c | 6 +- 13 files changed, 388 insertions(+), 260 deletions(-) diff --git a/lustre/include/linux/lustre_disk.h b/lustre/include/linux/lustre_disk.h index 5bd924f..24c397b 100644 --- a/lustre/include/linux/lustre_disk.h +++ b/lustre/include/linux/lustre_disk.h @@ -68,42 +68,48 @@ struct lr_server_data { #define LDD_SV_TYPE_OST 0x0002 #define LDD_SV_TYPE_MGMT 0x0004 -enum { +enum ldd_mount_type { LDD_MT_EXT3 = 0, LDD_MT_LDISKFS, LDD_MT_SMFS, - LDD_MT_REISERFS + LDD_MT_REISERFS, + LDD_MT_LAST }; -static char mount_type_string[4][] = { - "ext3", - "ldiskfs", - "smfs", - "reiserfs" +static inline char *mt_str(enum ldd_mount_type mt) +{ + static char *mount_type_string[] = { + "ext3", + "ldiskfs", + "smfs", + "reiserfs", + }; + //LASSERT(mt < LDD_MT_LAST); + return mount_type_string[mt]; } +struct host_desc { + ptl_nid_t primary; + ptl_nid_t backup; +}; + struct lustre_disk_data { __u32 ldd_magic; - __u32 ldd_flags; + __u32 ldd_flags; /* LDD_SV_TYPE */ 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_* */ + enum ldd_mount_type ldd_mount_type; /* target fs type LDD_MT_* */ char ldd_mount_opts[128]; /* target fs mount opts */ }; #define IS_MDT(data) ((data)->ldd_flags & LDD_SV_TYPE_MDT) #define IS_OST(data) ((data)->ldd_flags & LDD_SV_TYPE_OST) #define IS_MGMT(data) ((data)->ldd_flags & LDD_SV_TYPE_MGMT) -#define MT_STR(data) mount_type_string[(data)->ldd_mount_type] +#define MT_STR(data) mt_str((data)->ldd_mount_type) /****************** mount command *********************/ -struct host_desc { - ptl_nid_t primary; - ptl_nid_t backup; -}; - /* Passed by mount - no persistent info here */ struct lustre_mount_data { __u32 lmd_magic; @@ -116,12 +122,15 @@ struct lustre_mount_data { _device_ mount options) */ }; -#define LMD_FLG_FLOCK 0x0001 /* Enable flock */ -#define LMD_FLG_MNTCNF 0x1000 /* MountConf compat */ -#define LMD_FLG_CLIENT 0x2000 /* Mounting a client only; no real device */ +#define LMD_FLG_FLOCK 0x0001 /* Enable flock */ +#define LMD_FLG_RECOVER 0x0002 /* Allow recovery */ +#define LMD_FLG_MNTCNF 0x1000 /* MountConf compat */ +#define LMD_FLG_CLIENT 0x2000 /* Mounting a client only; no real device */ +/* 2nd half is for old clients */ #define lmd_is_client(x) \ - (((x)->lmd_flags & LMD_FLG_CLIENT) || (!((x)->lmd_flags & LMD_FLG_MNTCNF))) + (((x)->lmd_flags & LMD_FLG_CLIENT) || \ + (!((x)->lmd_flags & LMD_FLG_MNTCNF))) /****************** mkfs command *********************/ diff --git a/lustre/include/linux/lvfs.h b/lustre/include/linux/lvfs.h index 2862b8d..ab25b08 100644 --- a/lustre/include/linux/lvfs.h +++ b/lustre/include/linux/lvfs.h @@ -82,6 +82,14 @@ void pop_ctxt(struct lvfs_run_ctxt *saved, struct lvfs_run_ctxt *new_ctx, struct dentry *simple_mkdir(struct dentry *dir, char *name, int mode, int fix); struct dentry *simple_mknod(struct dentry *dir, char *name, int mode, int fix); + +struct ll_sb_info *lustre_init_sbi(struct super_block *sb); +void lustre_free_sbi(struct super_block *sb); +void lustre_manual_cleanup(struct ll_sb_info *sbi); +int lustre_fill_super(struct super_block *sb, void *data, int silent); +void lustre_put_super(struct super_block *sb); +int lustre_remount_fs(struct super_block *sb, int *flags, char *data); + int lustre_fread(struct file *file, void *buf, int len, loff_t *off); int lustre_fwrite(struct file *file, const void *buf, int len, loff_t *off); int lustre_fsync(struct file *file); diff --git a/lustre/include/linux/obd.h b/lustre/include/linux/obd.h index 8f09bf2..d47949d 100644 --- a/lustre/include/linux/obd.h +++ b/lustre/include/linux/obd.h @@ -499,35 +499,36 @@ enum llog_ctxt_id { /* corresponds to one of the obd's */ struct obd_device { - struct obd_type *obd_type; + struct obd_type *obd_type; /* common and UUID name of this device */ - char *obd_name; - struct obd_uuid obd_uuid; + char *obd_name; + struct obd_uuid obd_uuid; + struct obd_uuid obd_grp_uuid; /* for manual cleanup */ - int obd_minor; + int obd_minor; unsigned int obd_attached:1, obd_set_up:1, obd_recovering:1, obd_abort_recovery:1, obd_replayable:1, obd_no_transno:1, obd_no_recov:1, obd_stopping:1, obd_starting:1, obd_force:1, obd_fail:1; - atomic_t obd_refcount; - wait_queue_head_t obd_refcount_waitq; - struct proc_dir_entry *obd_proc_entry; - struct list_head obd_exports; - int obd_num_exports; - struct ldlm_namespace *obd_namespace; - struct ptlrpc_client obd_ldlm_client; /* XXX OST/MDS only */ + atomic_t obd_refcount; + wait_queue_head_t obd_refcount_waitq; + struct proc_dir_entry *obd_proc_entry; + struct list_head obd_exports; + int obd_num_exports; + struct ldlm_namespace *obd_namespace; + struct ptlrpc_client obd_ldlm_client; /* XXX OST/MDS only */ /* a spinlock is OK for what we do now, may need a semaphore later */ - spinlock_t obd_dev_lock; - __u64 obd_last_committed; + spinlock_t obd_dev_lock; + __u64 obd_last_committed; struct fsfilt_operations *obd_fsops; spinlock_t obd_osfs_lock; struct obd_statfs obd_osfs; - unsigned long obd_osfs_age; /* jiffies */ + unsigned long obd_osfs_age; /* jiffies */ struct lvfs_run_ctxt obd_lvfs_ctxt; - struct llog_ctxt *obd_llog_ctxt[LLOG_MAX_CTXTS]; - struct obd_device *obd_observer; - struct obd_export *obd_self_export; + struct llog_ctxt *obd_llog_ctxt[LLOG_MAX_CTXTS]; + struct obd_device *obd_observer; + struct obd_export *obd_self_export; struct list_head obd_exports_timed; /* for ping evictor */ time_t obd_eviction_timer; /* for ping evictor */ diff --git a/lustre/include/lustre/lustre_user.h b/lustre/include/lustre/lustre_user.h index 4085255..d976d7d 100644 --- a/lustre/include/lustre/lustre_user.h +++ b/lustre/include/lustre/lustre_user.h @@ -60,7 +60,7 @@ #define LL_FILE_GROUP_LOCKED 0x00000002 #define LL_FILE_READAHEAD 0x00000004 #define LL_UMOUNT_FORCE 0x00000010 -#define LL_UMOUNT_FAIL 0x00000020 +#define LL_UMOUNT_FAILOVER 0x00000020 #define LOV_USER_MAGIC_V1 0x0BD10BD0 #define LOV_USER_MAGIC LOV_USER_MAGIC_V1 diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h index eb167b6..6dbf785 100644 --- a/lustre/llite/llite_internal.h +++ b/lustre/llite/llite_internal.h @@ -131,7 +131,10 @@ struct ll_sb_info { struct proc_dir_entry* ll_proc_root; obd_id ll_rootino; /* number of root inode */ - struct lustre_mount_data *ll_lmd; + struct lvfs_run_ctxt ll_ctxt; /* mount context */ + struct lustre_mount_data *ll_lmd; /* mount command info */ + struct lustre_disk_data *ll_ldd; /* mount info on-disk */ + struct fsfilt_operations *ll_fsops; int ll_flags; struct list_head ll_conn_chain; /* per-conn chain of SBs */ @@ -336,7 +339,7 @@ int ll_set_opt(const char *opt, char *data, int fl); void ll_options(char *options, char **ost, char **mds, int *flags); void ll_lli_init(struct ll_inode_info *lli); int ll_fill_super(struct super_block *sb, void *data, int silent); -int client_fill_super(struct super_block *sb, void *data); +int client_fill_super(struct super_block *sb); void client_put_super(struct super_block *sb); struct inode *ll_inode_from_lock(struct ldlm_lock *lock); void ll_clear_inode(struct inode *inode); @@ -351,7 +354,6 @@ void ll_read_inode2(struct inode *inode, void *opaque); int ll_iocontrol(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg); void ll_umount_begin(struct super_block *sb); -int lustre_remount_fs(struct super_block *sb, int *flags, char *data); int ll_prep_inode(struct obd_export *exp, struct inode **inode, struct ptlrpc_request *req, int offset, struct super_block *); void lustre_dump_dentry(struct dentry *, int recur); diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c index 4128cd1..2d16993 100644 --- a/lustre/llite/llite_lib.c +++ b/lustre/llite/llite_lib.c @@ -412,11 +412,11 @@ out: RETURN(err); } /* ll_read_super */ -int client_fill_super(struct super_block *sb, - struct lustre_mount_data * lmd) +int client_fill_super(struct super_block *sb) { struct lustre_profile *lprof; struct ll_sb_info *sbi = ll_s2sbi(sb); + struct lustre_mount_data *lmd = sbi->ll_lmd; char * osc = NULL; char * mdc = NULL; char ll_instance[sizeof(sb) * 2 + 1]; diff --git a/lustre/lvfs/lvfs_mount.c b/lustre/lvfs/lvfs_mount.c index 216c54a..f0da60a 100644 --- a/lustre/lvfs/lvfs_mount.c +++ b/lustre/lvfs/lvfs_mount.c @@ -30,12 +30,50 @@ #include -/* requires a mounted device */ -int parse_last_rcvd(struct obd_device *obd, char *uuid, int *first_mount) +int parse_mount_data(struct lvfs_run_ctxt *mount_ctxt, + struct lustre_disk_data *ldd) +{ + struct lvfs_run_ctxt saved; + struct file *file; + loff_t off = 0; + unsigned long len; + + push_ctxt(&saved, mount_ctxt, NULL); + + file = filp_open(MOUNT_DATA_FILE, O_RDONLY, 0644); + if (IS_ERR(file)) { + rc = PTR_ERR(file); + CERROR("cannot open %s: rc = %d\n", MOUNT_DATA_FILE, rc); + goto out; + } + + len = file->f_dentry->d_inode->i_size; + CERROR("Have last_rcvd, size %lu\n", len); + + rc = lustre_fread(file, ldd, len, &off); + if (rc) { + CERROR("OBD filter: error reading %s: rc %d\n", + MOUNT_DATA_FILE, rc); + goto out_close; + } + if (ldd->ldd_magic != LDD_MAGIC) { + CERROR("Bad magic in %s: %x!=%x\n", MOUNT_DATA_FILE, + ldd->ldd_magic, LDD_MAGIC); + rc = -EINVAL; + } + +out_close: + filp_close(file, 0); +out: + pop_ctxt(&saved, mount_ctxt, NULL); + return(rc); +} + +int parse_last_rcvd(struct ll_sb_info *sbi, + char *uuid, int *first_mount) { struct lvfs_run_ctxt saved; struct file *file; - /* FIXME filter_server_data and mds_server_data are identical?? should merge*/ struct lr_server_data *lsd; loff_t off = 0; int rc; @@ -44,8 +82,9 @@ int parse_last_rcvd(struct obd_device *obd, char *uuid, int *first_mount) if (!lsd) return -ENOMEM; - /*setup llog ctxt*/ - push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); + /* requires a mounted device */ + LASSERT(sbi->ll_ctxt.pwdmnt); + push_ctxt(&saved, &sbi->ll_ctxt, NULL); /* open and test the last rcvd file */ file = filp_open(LAST_RCVD, O_RDONLY, 0644); @@ -57,7 +96,9 @@ int parse_last_rcvd(struct obd_device *obd, char *uuid, int *first_mount) CERROR("Have last_rcvd, size %lu\n", (unsigned long)file->f_dentry->d_inode->i_size); - rc = fsfilt_read_record(obd, file, lsd, sizeof(*lsd), &off); + LASSERT(sbi->ll_fsops); + rc = sbi->ll_fsops->fs_read_record(file, lsd, sizeof(*lsd), &off); + //rc = fsfilt_read_record(obd, file, lsd, sizeof(*lsd), &off); if (rc) { CERROR("OBD filter: error reading %s: rc %d\n", LAST_RCVD, rc); goto out_close; @@ -70,7 +111,7 @@ int parse_last_rcvd(struct obd_device *obd, char *uuid, int *first_mount) out_close: filp_close(file, 0); out: - pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL); + pop_ctxt(&saved, &sbi->ll_ctxt, NULL); OBD_FREE(lsd, sizeof(*lsd)); return(rc); } @@ -120,7 +161,7 @@ static int class_manual_cleanup(struct obd_device *obd, char *flags) return(rc); } -static void lustre_manual_cleanup(struct ll_sb_info *sbi) +void lustre_manual_cleanup(struct ll_sb_info *sbi) { while ((obd = class_devices_in_group(&sbi->ll_sb_uuid, &next)) != NULL) class_manual_cleanup(obd, NULL); @@ -198,6 +239,8 @@ void lustre_free_sbi(struct super_block *sb) spin_lock(&ll_sb_lock); list_del(&sbi->ll_list); spin_unlock(&ll_sb_lock); + if (sbi->ll_ldd != NULL) + OBD_FREE(sbi->ll_ldd, sizeof(*sbi->ll_ldd)); OBD_FREE(sbi, sizeof(*sbi)); } ll_s2sbi_nocast(sb) = NULL; @@ -210,21 +253,23 @@ static void server_put_super(struct super_block *sb) struct ll_sb_info *sbi = ll_s2sbi(sb); struct l_linux_dirent *dirent, *n; struct obd_device *obd; - struct conf_obd *confobd; + struct mgmtcli_obd *mcobd; char logname[LOG_NAME_MAX]; char flags[2] = ""; int err; + //FIXME create MGC + CERROR("server put_super uuid %s\n", sbi->ll_sb_uuid.uuid); obd = class_uuid2obd(&sbi->ll_sb_uuid); if (!obd) { - CERROR("Can't get confobd %s\n", sbi->ll_sb_uuid.uuid); + CERROR("Can't get mcobd %s\n", sbi->ll_sb_uuid.uuid); return; } - confobd = &obd->u.confobd; + mcobd = &obd->u.mgmtcli; - if (confobd->cfobd_logs_info.ost_number > 0) { + if (mcobd->cfobd_logs_info.ost_number > 0) { struct obd_ioctl_data ioc_data = { 0 }; CERROR("update new logs.\n"); err = obd_iocontrol(OBD_IOC_UPDATE_LOG, obd->obd_self_export, @@ -234,22 +279,22 @@ static void server_put_super(struct super_block *sb) } /* Find all the logs in the LOGS directory */ - err = dentry_readdir(obd, confobd->cfobd_logs_dir, - confobd->cfobd_lvfs_ctxt->loc_mnt, + err = dentry_readdir(obd, mcobd->cfobd_logs_dir, + mcobd->cfobd_lvfs_ctxt->loc_mnt, &dentry_list); if (err) CERROR("Can't read LOGS dir, %d\n", err); if (sbi->ll_flags & LL_UMOUNT_FORCE) strcat(flags, "A"); - if (sbi->ll_flags & LL_UMOUNT_FAIL) + if (sbi->ll_flags & LL_UMOUNT_FAILOVER) strcat(flags, "F"); /* Clean up all the -conf obd's in the LOGS directory. FIXME this may not be complete / reasonable. Really, we should have a list of every obd we started, maybe an additional field to obd_device for group_uuid, then - just use lustre_manual_cleanup. + just use lustre_manual_cleanup. CRAY_MDS: client client-clean mdsA mdsA-clean mdsA-conf CRAY_OST: @@ -291,12 +336,14 @@ static void server_put_super(struct super_block *sb) if (obd) class_manual_cleanup(obd, flags); - /* Cleanup the confobd itself */ + /* Cleanup the mcobd itself */ if (sbi->ll_lmd != NULL) { lustre_manual_cleanup(sbi); OBD_FREE(sbi->ll_lmd, sizeof(*sbi->ll_lmd)); - OBD_FREE(sbi->ll_instance, strlen(sbi->ll_instance) + 1); } + + //FIXME cleanup does the mntput; we have to make sure MGS is done with + //it as well - we should probably do it here. lustre_free_sbi(sb); } @@ -306,6 +353,7 @@ static void server_umount_force(struct super_block *sb) struct ll_sb_info *sbi = ll_s2sbi(sb); CERROR("Umount -f\n"); + // FIXME decide FORCE or FAILOVER based on mount option -o umount=failover sbi->ll_flags |= LL_UMOUNT_FORCE; } @@ -326,7 +374,7 @@ static int server_fill_super(struct super_block *sb) sb->s_blocksize = 4096; sb->s_blocksize_bits = log2(sb->s_blocksize); - sb->s_magic = LL_SUPER_MAGIC; /* FIXME different magic? */ + sb->s_magic = LL_SUPER_MAGIC; sb->s_maxbytes = PAGE_CACHE_MAXBYTES; sb->s_flags |= MS_RDONLY; sb->s_op = &server_ops; @@ -353,10 +401,10 @@ static int server_fill_super(struct super_block *sb) } /* Get the log "profile" from a remote MGMT and process it. - FIXME If remote doesn't exists, try local + FIXME If remote doesn't exist, try local This func should work for both clients and servers */ int lustre_get_process_log(struct lustre_mount_data *lmd, char * profile, - struct config_llog_instance *cfg, int allow_recov) + struct config_llog_instance *cfg) { char * peer = "MDS_PEER_UUID"; struct obd_device *obd; @@ -367,13 +415,10 @@ int lustre_get_process_log(struct lustre_mount_data *lmd, char * profile, class_uuid_t uuid; struct obd_uuid mdc_uuid; struct llog_ctxt *ctxt; - int rc = 0; - int err; + int allow_recov = (lmd->lmd_flags & LMD_FLG_RECOVER) > 0; + int err, rc = 0; ENTRY; - if (lmd_bad_magic(lmd)) - RETURN(-EINVAL); - LASSERT(lmd->lmd_mgmtnid.primary != PTL_NID_ANY); lustre_generate_random_uuid(uuid); @@ -469,7 +514,7 @@ out: /* Process all local logs. FIXME clients and servers should use the same fn. No need to have MDS -do client and confobd do servers. */ +do client and confobd do servers. MGC should do both. */ int lustre_process_logs(struct lustre_mount_data *lmd, struct config_llog_instance *cfg, int allow_recov) { @@ -477,44 +522,37 @@ int lustre_process_logs(struct lustre_mount_data *lmd, struct list_head dentry_list; struct l_linux_dirent *dirent, *n; struct obd_device *obd; - struct conf_obd *confobd; + struct mgmtcli_obd *mcobd; char lr_uuid[40]; char logname[LOG_NAME_MAX]; - char confname[40]; + char mcname[40]; int is_first_mount = 0; int err; - if (lmd_bad_magic(lmd)) - return(-EINVAL); - - if (lmd_is_client(lmd)) { - return(lustre_get_process_log(lmd, lmd->lmd_dev, - cfg, allow_recov)); - } - /* We're a server, set up a confobd to process the logs */ - sprintf(confname, "CONF%s ", lmd->lmd_fsname); - err = do_lcfg(LCFG_ATTACH, confname, LUSTRE_CONFOBD_NAME, + /* We're a server, set up a mcobd to process the logs */ + sprintf(mcname, "CONF%s ", lmd->lmd_dev); + err = do_lcfg(LCFG_ATTACH, mcname, LUSTRE_CONFOBD_NAME, cfg->cfg_uuid.uuid, 0, 0); if (err) return(err); /* Apparently servers mount the fs on top of the confobd mount, so our confobd mount options must be the same as the server?? */ - err = do_lcfg(LCFG_SETUP, confname, lmd->u.srv.lmd_source, + err = do_lcfg(LCFG_SETUP, mcname, lmd->u.srv.lmd_source, lmd->u.srv.lmd_fstype, lmd->u.srv.lmd_fsopts, 0); if (err) { - CERROR("confobd setup error %d\n", err); - do_lcfg(LCFG_DETACH, confname, 0, 0, 0, 0); + CERROR("mcobd setup error %d\n", err); + do_lcfg(LCFG_DETACH, mcname, 0, 0, 0, 0); return(err); } - obd = class_name2obd(confname); + obd = class_name2obd(mcname); if (!obd) { - CERROR("Can't find confobd %s\n", confname); + CERROR("Can't find mcobd %s\n", mcname); return(-ENOTCONN); } - confobd = &obd->u.confobd; + mcobd = &obd->u.mgmtcli; err = parse_last_rcvd(obd, lr_uuid, &is_first_mount); if (err) { @@ -539,13 +577,13 @@ int lustre_process_logs(struct lustre_mount_data *lmd, CERROR("Can't read %s\n", STRIPE_FILE); return(err); } - confobd_start_accept(obd, lmd, lr_uuid, stripe_size); + mcobd_start_accept(obd, lmd, lr_uuid, stripe_size); #endif } /* Find all the logs in the LOGS directory */ - err = dentry_readdir(obd, confobd->cfobd_logs_dir, - confobd->cfobd_lvfs_ctxt->loc_mnt, + err = dentry_readdir(obd, mcobd->cfobd_logs_dir, + mcobd->cfobd_lvfs_ctxt->loc_mnt, &dentry_list); if (err) { CERROR("Can't read LOGS dir\n"); @@ -580,44 +618,90 @@ int lustre_process_logs(struct lustre_mount_data *lmd, return(err); } -static int lustre_kern_mount(struct lustre_mount_data *lmd) +/* Kernel mount using mount options in MOUNT_DATA_FILE */ +static int lustre_kern_mount(struct ll_sb_info *sbi) { + struct lvfs_run_ctxt mount_ctxt; + struct lvfs_run_ctxt saved; struct lustre_disk_data *ldd; + struct lustre_mount_data *lmd = sbi->ll_lmd; char *options = NULL; struct vfsmount *mnt; unsigned long page; + int rc; OBD_ALLOC(ldd, sizeof(*ldd)); if (!ldd) return(-ENOMEM); - - //FIXME read MOUNT_DATA_FILE - page = __get_free_page(GFP_KERNEL); - if (!page) - return(-ENOMEM); + /* Pre-mount ext3 with no options to read the MOUNT_DATA_FILE */ + CERROR("Pre-mount ext3 %s\n", lmd->lmd_dev); + mnt = do_kern_mount("ext3", 0, lmd->lmd_dev, 0); + if (IS_ERR(mnt)) { + rc = PTR_ERR(mnt); + CERROR("premount failed: rc = %d\n", rc); + goto out_free; + } + + OBD_SET_CTXT_MAGIC(&mount_ctxt); + mount_ctxt.pwdmnt = mnt; + mount_ctxt.pwd = mnt->mnt_root; + mount_ctxt.fs = get_ds(); + //mount_ctxt.cb_ops = mds_lvfs_ops; + + rc = parse_mount_data(&mount_ctxt, ldd); + //unlock_kernel(); + mntput(mnt); + //lock_kernel(); + + if (rc) { + CERROR("premount parse options failed: rc = %d\n", rc); + goto out_free; + } + + /* Done with our pre-mount, now do the real mount. */ + /* Glom up mount options */ + page = __get_free_page(GFP_KERNEL); + if (!page) { + rc = -ENOMEM; + goto out_free; + } options = (char *)page; memset(options, 0, PAGE_SIZE); + strcpy(options, ldd->ldd_mount_opts); + if (strlen(lmd->lmd_opts)) { + if (strlen(options)) + strcat(options, ","); + strcat(options, ldd->ldd_mount_opts); + } - /* lctl_setup 1:/dev/loop/0 2:ext3 3:mdsA 4:errors=remount-ro,iopen_nopriv*/ - if (LUSTRE_CFG_BUFLEN(lcfg, 4) > 0 && lustre_cfg_buf(lcfg, 4)) - sprintf(options + strlen(options), ",%s", - lustre_cfg_string(lcfg, 4)); + CERROR("kern_mount: %s %s %s\n", MT_STR(ldd), lmd->lmd_dev, options); - mnt = do_kern_mount(MT_STR(ldd), 0, - lmd->lmd_dev, - (void *)ldd->ldd_mount_opts); + mnt = do_kern_mount(MT_STR(ldd), 0, lmd->lmd_dev, (void *)options); free_page(page); if (IS_ERR(mnt)) { rc = PTR_ERR(mnt); CERROR("do_kern_mount failed: rc = %d\n", rc); - GOTO(err_ops, rc); + goto out_free; } - CDEBUG(D_SUPER, "%s: mnt = %p\n", lustre_cfg_string(lcfg, 1), mnt); + /* ldd freed at sbi cleanup */ + sbi->ll_ldd = ldd; + sbi->ll_ctxt.pwdmnt = mnt; + sbi->ll_ctxt.pwd = mnt->mnt_root; + sbi->ll_ctxt.fs = get_ds(); + sbi->ll_fsops = fsfilt_get_ops(MT_STR(ldd)); + + CDEBUG(D_SUPER, "%s: mnt = %p\n", lmd->lmd_dev, mnt); + return(0); + +out_free: + OBD_FREE(ldd, sizeof(*ldd)); + return(rc); } +/* Common mount */ int lustre_fill_super(struct super_block *sb, void *data, int silent) { struct lustre_mount_data * lmd = data; @@ -647,35 +731,52 @@ int lustre_fill_super(struct super_block *sb, void *data, int silent) sprintf(ll_instance, "%p", sb); cfg.cfg_instance = ll_instance; cfg.cfg_uuid = sbi->ll_sb_uuid; - - if (!lmd_is_client(lmd)) { - err = lustre_kern_mount(lmd); - if (err) { - CERROR("Unable to mount device %s: %d\n", - lmd->lmd_dev, err); - GOTO(out_free, err); - } - } + + /*FIXME mgc = create_mgc(sbi); + name "fsname-mgc"? or 1 mgc per node? + */ - /* sets up all obd devices (server or client) */ - err = lustre_process_logs(lmd, &cfg, 0); - if (err < 0) { - CERROR("Unable to process log: %d\n", err); - GOTO(out_free, err); - } - if (lmd_is_client(lmd)) { + err = lustre_get_process_log(lmd, + lmd->lmd_dev/* FIXME or "client"?*/, + &cfg) + if (err < 0) { + CERROR("Unable to process log: %d\n", err); + GOTO(out_free, err); + } /* Connect and start */ - err = client_fill_super(sb, lmd); + err = client_fill_super(sb); if (err < 0) { CERROR("Unable to mount client: %s\n", lmd->u.cli.lmd_profile); GOTO(out_free, err); } + } else { + /* Server, so mount to read server info */ + err = lustre_kern_mount(sbi); + if (err) { + CERROR("Unable to mount device %s: %d\n", + lmd->lmd_dev, err); + GOTO(out_free, err); + } + CERROR("Found service %s for fs %s on device %s\n", + sbi->ll_ldd->ldd_svname, sbi->ll_ldd->ldd_fsname, + lmd->lmd_dev); + + /* Set up all obd devices for service */ + err = lustre_process_logs(lmd, &cfg, 0); + if (err < 0) { + CERROR("Unable to process log: %d\n", err); + GOTO(out_free, err); + } + + /* Finally, put something at the mount point. */ CERROR("Mounting server\n"); err = server_fill_super(sb); - // FIXME overmount client here + /* FIXME overmount client here, + or can we just start a client log and client_fill_super on this sb? + have to fix up the s_ops after! */ } RETURN(err); @@ -690,8 +791,19 @@ out_free: RETURN(err); } /* lustre_fill_super */ +/* Common umount */ +void lustre_put_super(struct super_block *sb) +{ + struct ll_sb_info *sbi = ll_s2sbi(sb); + if (sbi->ll_lmd && !lmd_is_client(sbi->ll_lmd) { + // FIXME unmount overmounted client first + return server_put_super(sb); + } else { + return client_put_super(sb); + } +} - +/* Common remount */ int lustre_remount_fs(struct super_block *sb, int *flags, char *data) { struct ll_sb_info *sbi = ll_s2sbi(sb); @@ -700,12 +812,17 @@ int lustre_remount_fs(struct super_block *sb, int *flags, char *data) if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) { read_only = *flags & MS_RDONLY; - err = obd_set_info(sbi->ll_mdc_exp, strlen("read-only"), - "read-only", sizeof(read_only), &read_only); - if (err) { - CERROR("Failed to change the read-only flag during " - "remount: %d\n", err); - return err; + if (sbi->ll_lmd && !lmd_is_client(sbi->ll_lmd) { + CERROR("Remount server RO %d\n", read_only); + } else { + err = obd_set_info(sbi->ll_mdc_exp, strlen("read-only"), + "read-only", sizeof(read_only), + &read_only); + if (err) { + CERROR("Failed to change the read-only flag " + "during remount: %d\n", err); + return err; + } } if (read_only) @@ -717,4 +834,10 @@ int lustre_remount_fs(struct super_block *sb, int *flags, char *data) } +EXPORT_SYMBOL(lustre_init_sbi); +EXPORT_SYMBOL(lustre_free_sbi); +EXPORT_SYMBOL(lustre_fill_super); +EXPORT_SYMBOL(lustre_put_super); +EXPORT_SYMBOL(lustre_manual_cleanup); +EXPORT_SYMBOL(lustre_remount_fs); diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c index 4c6e9e7..89f0400 100644 --- a/lustre/mds/handler.c +++ b/lustre/mds/handler.c @@ -1456,6 +1456,8 @@ static int mds_setup(struct obd_device *obd, obd_count len, void *buf) int rc = 0; ENTRY; + /* setup 1:/dev/loop/0 2:ext3 3:mdsA 4:errors=remount-ro,iopen_nopriv*/ + if (lcfg->lcfg_bufcount < 3) RETURN(rc = -EINVAL); @@ -1482,6 +1484,8 @@ static int mds_setup(struct obd_device *obd, obd_count len, void *buf) sprintf(options + strlen(options), ",%s", lustre_cfg_string(lcfg, 4)); + //FIXME mount was already done in lustre_fill_super, + //we just need to access it mnt = do_kern_mount(lustre_cfg_string(lcfg, 2), 0, lustre_cfg_string(lcfg, 1), (void *)options); free_page(page); diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c index 8117b51..66ac2c7 100644 --- a/lustre/obdfilter/filter.c +++ b/lustre/obdfilter/filter.c @@ -55,6 +55,7 @@ #include #include #include +#include #include #include "filter_internal.h" @@ -88,15 +89,15 @@ int filter_finish_transno(struct obd_export *exp, struct obd_trans_info *oti, /* we don't allocate new transnos for replayed requests */ if (oti->oti_transno == 0) { spin_lock(&filter->fo_translock); - last_rcvd = le64_to_cpu(filter->fo_fsd->fsd_last_transno) + 1; - filter->fo_fsd->fsd_last_transno = cpu_to_le64(last_rcvd); + last_rcvd = le64_to_cpu(filter->fo_fsd->lsd_last_transno) + 1; + filter->fo_fsd->lsd_last_transno = cpu_to_le64(last_rcvd); spin_unlock(&filter->fo_translock); oti->oti_transno = last_rcvd; } else { spin_lock(&filter->fo_translock); last_rcvd = oti->oti_transno; - if (last_rcvd > le64_to_cpu(filter->fo_fsd->fsd_last_transno)) - filter->fo_fsd->fsd_last_transno = + if (last_rcvd > le64_to_cpu(filter->fo_fsd->lsd_last_transno)) + filter->fo_fsd->lsd_last_transno = cpu_to_le64(last_rcvd); spin_unlock(&filter->fo_translock); } @@ -181,8 +182,8 @@ static int filter_client_add(struct obd_device *obd, struct filter_obd *filter, } fed->fed_lr_idx = cl_idx; - fed->fed_lr_off = le32_to_cpu(filter->fo_fsd->fsd_client_start) + - cl_idx * le16_to_cpu(filter->fo_fsd->fsd_client_size); + fed->fed_lr_off = le32_to_cpu(filter->fo_fsd->lsd_client_start) + + cl_idx * le16_to_cpu(filter->fo_fsd->lsd_client_size); LASSERTF(fed->fed_lr_off > 0, "fed_lr_off = %llu\n", fed->fed_lr_off); CDEBUG(D_INFO, "client at index %d (%llu) with UUID '%s' added\n", @@ -309,21 +310,21 @@ static int filter_free_server_data(struct filter_obd *filter) /* assumes caller is already in kernel ctxt */ int filter_update_server_data(struct obd_device *obd, struct file *filp, - struct filter_server_data *fsd, int force_sync) + struct lr_server_data *fsd, int force_sync) { loff_t off = 0; int rc; ENTRY; - CDEBUG(D_INODE, "server uuid : %s\n", fsd->fsd_uuid); + CDEBUG(D_INODE, "server uuid : %s\n", fsd->lsd_uuid); CDEBUG(D_INODE, "server last_rcvd : "LPU64"\n", - le64_to_cpu(fsd->fsd_last_transno)); + le64_to_cpu(fsd->lsd_last_transno)); CDEBUG(D_INODE, "server last_mount: "LPU64"\n", - le64_to_cpu(fsd->fsd_mount_count)); + le64_to_cpu(fsd->lsd_mount_count)); rc = fsfilt_write_record(obd, filp, fsd, sizeof(*fsd), &off,force_sync); if (rc) - CERROR("error writing filter_server_data: rc = %d\n", rc); + CERROR("error writing lr_server_data: rc = %d\n", rc); RETURN(rc); } @@ -353,7 +354,7 @@ int filter_update_last_objid(struct obd_device *obd, obd_gr group, static int filter_init_server_data(struct obd_device *obd, struct file * filp) { struct filter_obd *filter = &obd->u.filter; - struct filter_server_data *fsd; + struct lr_server_data *fsd; struct filter_client_data *fcd = NULL; struct inode *inode = filp->f_dentry->d_inode; unsigned long last_rcvd_size = inode->i_size; @@ -363,8 +364,8 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) int rc; /* ensure padding in the struct is the correct size */ - LASSERT (offsetof(struct filter_server_data, fsd_padding) + - sizeof(fsd->fsd_padding) == FILTER_LR_SERVER_SIZE); + LASSERT (offsetof(struct lr_server_data, lsd_padding) + + sizeof(fsd->lsd_padding) == FILTER_LR_SERVER_SIZE); LASSERT (offsetof(struct filter_client_data, fcd_padding) + sizeof(fcd->fcd_padding) == FILTER_LR_CLIENT_SIZE); @@ -382,13 +383,13 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) if (last_rcvd_size == 0) { CWARN("%s: initializing new %s\n", obd->obd_name, LAST_RCVD); - memcpy(fsd->fsd_uuid, obd->obd_uuid.uuid,sizeof(fsd->fsd_uuid)); - fsd->fsd_last_transno = 0; - mount_count = fsd->fsd_mount_count = 0; - fsd->fsd_server_size = cpu_to_le32(FILTER_LR_SERVER_SIZE); - fsd->fsd_client_start = cpu_to_le32(FILTER_LR_CLIENT_START); - fsd->fsd_client_size = cpu_to_le16(FILTER_LR_CLIENT_SIZE); - fsd->fsd_subdir_count = cpu_to_le16(FILTER_SUBDIR_COUNT); + memcpy(fsd->lsd_uuid, obd->obd_uuid.uuid,sizeof(fsd->lsd_uuid)); + fsd->lsd_last_transno = 0; + mount_count = fsd->lsd_mount_count = 0; + fsd->lsd_server_size = cpu_to_le32(FILTER_LR_SERVER_SIZE); + fsd->lsd_client_start = cpu_to_le32(FILTER_LR_CLIENT_START); + fsd->lsd_client_size = cpu_to_le16(FILTER_LR_CLIENT_SIZE); + fsd->lsd_subdir_count = cpu_to_le16(FILTER_SUBDIR_COUNT); filter->fo_subdir_count = FILTER_SUBDIR_COUNT; } else { rc = fsfilt_read_record(obd, filp, fsd, sizeof(*fsd), &off); @@ -397,52 +398,52 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) LAST_RCVD, rc); GOTO(err_fsd, rc); } - if (strcmp(fsd->fsd_uuid, obd->obd_uuid.uuid) != 0) { + if (strcmp(fsd->lsd_uuid, obd->obd_uuid.uuid) != 0) { CERROR("OBD UUID %s does not match last_rcvd UUID %s\n", - obd->obd_uuid.uuid, fsd->fsd_uuid); + obd->obd_uuid.uuid, fsd->lsd_uuid); GOTO(err_fsd, rc = -EINVAL); } - mount_count = le64_to_cpu(fsd->fsd_mount_count); - filter->fo_subdir_count = le16_to_cpu(fsd->fsd_subdir_count); + mount_count = le64_to_cpu(fsd->lsd_mount_count); + filter->fo_subdir_count = le16_to_cpu(fsd->lsd_subdir_count); } - if (fsd->fsd_feature_incompat & ~cpu_to_le32(FILTER_INCOMPAT_SUPP)) { + if (fsd->lsd_feature_incompat & ~cpu_to_le32(FILTER_INCOMPAT_SUPP)) { CERROR("unsupported feature %x\n", - le32_to_cpu(fsd->fsd_feature_incompat) & + le32_to_cpu(fsd->lsd_feature_incompat) & ~FILTER_INCOMPAT_SUPP); GOTO(err_fsd, rc = -EINVAL); } - if (fsd->fsd_feature_rocompat & ~cpu_to_le32(FILTER_ROCOMPAT_SUPP)) { + if (fsd->lsd_feature_rocompat & ~cpu_to_le32(FILTER_ROCOMPAT_SUPP)) { CERROR("read-only feature %x\n", - le32_to_cpu(fsd->fsd_feature_rocompat) & + le32_to_cpu(fsd->lsd_feature_rocompat) & ~FILTER_ROCOMPAT_SUPP); /* Do something like remount filesystem read-only */ GOTO(err_fsd, rc = -EINVAL); } CDEBUG(D_INODE, "%s: server last_rcvd : "LPU64"\n", - obd->obd_name, le64_to_cpu(fsd->fsd_last_transno)); + obd->obd_name, le64_to_cpu(fsd->lsd_last_transno)); CDEBUG(D_INODE, "%s: server mount_count: "LPU64"\n", obd->obd_name, mount_count + 1); CDEBUG(D_INODE, "%s: server data size: %u\n", - obd->obd_name, le32_to_cpu(fsd->fsd_server_size)); + obd->obd_name, le32_to_cpu(fsd->lsd_server_size)); CDEBUG(D_INODE, "%s: per-client data start: %u\n", - obd->obd_name, le32_to_cpu(fsd->fsd_client_start)); + obd->obd_name, le32_to_cpu(fsd->lsd_client_start)); CDEBUG(D_INODE, "%s: per-client data size: %u\n", - obd->obd_name, le32_to_cpu(fsd->fsd_client_size)); + obd->obd_name, le32_to_cpu(fsd->lsd_client_size)); CDEBUG(D_INODE, "%s: server subdir_count: %u\n", - obd->obd_name, le16_to_cpu(fsd->fsd_subdir_count)); + obd->obd_name, le16_to_cpu(fsd->lsd_subdir_count)); CDEBUG(D_INODE, "%s: last_rcvd clients: %lu\n", obd->obd_name, - last_rcvd_size <= le32_to_cpu(fsd->fsd_client_start) ? 0 : - (last_rcvd_size - le32_to_cpu(fsd->fsd_client_start)) / - le16_to_cpu(fsd->fsd_client_size)); + last_rcvd_size <= le32_to_cpu(fsd->lsd_client_start) ? 0 : + (last_rcvd_size - le32_to_cpu(fsd->lsd_client_start)) / + le16_to_cpu(fsd->lsd_client_size)); if (!obd->obd_replayable) { CWARN("%s: recovery support OFF\n", obd->obd_name); GOTO(out, rc = 0); } - for (cl_idx = 0, off = le32_to_cpu(fsd->fsd_client_start); + for (cl_idx = 0, off = le32_to_cpu(fsd->lsd_client_start); off < last_rcvd_size; cl_idx++) { __u64 last_rcvd; struct obd_export *exp; @@ -456,9 +457,9 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) /* Don't assume off is incremented properly by * fsfilt_read_record(), in case sizeof(*fcd) - * isn't the same as fsd->fsd_client_size. */ - off = le32_to_cpu(fsd->fsd_client_start) + - cl_idx * le16_to_cpu(fsd->fsd_client_size); + * isn't the same as fsd->lsd_client_size. */ + off = le32_to_cpu(fsd->lsd_client_start) + + cl_idx * le16_to_cpu(fsd->lsd_client_size); rc = fsfilt_read_record(obd, filp, fcd, sizeof(*fcd), &off); if (rc) { CERROR("error reading FILT %s idx %d off %llu: rc %d\n", @@ -480,7 +481,7 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) exp = class_new_export(obd); CDEBUG(D_HA, "RCVRNG CLIENT uuid: %s idx: %d lr: "LPU64 " srv lr: "LPU64"\n", fcd->fcd_uuid, cl_idx, - last_rcvd, le64_to_cpu(fsd->fsd_last_transno)); + last_rcvd, le64_to_cpu(fsd->lsd_last_transno)); if (exp == NULL) GOTO(err_client, rc = -ENOMEM); @@ -503,21 +504,21 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) CDEBUG(D_OTHER, "client at idx %d has last_rcvd = "LPU64"\n", cl_idx, last_rcvd); - if (last_rcvd > le64_to_cpu(fsd->fsd_last_transno)) - fsd->fsd_last_transno = cpu_to_le64(last_rcvd); + if (last_rcvd > le64_to_cpu(fsd->lsd_last_transno)) + fsd->lsd_last_transno = cpu_to_le64(last_rcvd); } if (fcd) OBD_FREE(fcd, sizeof(*fcd)); - obd->obd_last_committed = le64_to_cpu(fsd->fsd_last_transno); + obd->obd_last_committed = le64_to_cpu(fsd->lsd_last_transno); if (obd->obd_recoverable_clients) { CWARN("RECOVERY: service %s, %d recoverable clients, " "last_rcvd "LPU64"\n", obd->obd_name, obd->obd_recoverable_clients, - le64_to_cpu(fsd->fsd_last_transno)); + le64_to_cpu(fsd->lsd_last_transno)); obd->obd_next_recovery_transno = obd->obd_last_committed + 1; obd->obd_recovering = 1; obd->obd_recovery_start = CURRENT_SECONDS; @@ -525,7 +526,7 @@ static int filter_init_server_data(struct obd_device *obd, struct file * filp) out: filter->fo_mount_count = mount_count + 1; - fsd->fsd_mount_count = cpu_to_le64(filter->fo_mount_count); + fsd->lsd_mount_count = cpu_to_le64(filter->fo_mount_count); /* save it, so mount count and last_transno is current */ rc = filter_update_server_data(obd, filp, filter->fo_fsd, 1); @@ -643,7 +644,7 @@ static int filter_prep_groups(struct obd_device *obd) CERROR("error renaming O/R to O/0: rc %d\n", rc); GOTO(cleanup_O0, rc); } - filter->fo_fsd->fsd_feature_incompat |= + filter->fo_fsd->lsd_feature_incompat |= cpu_to_le32(FILTER_INCOMPAT_GROUPS); rc = filter_update_server_data(obd, filter->fo_rcvd_filp, filter->fo_fsd, 1); @@ -696,10 +697,10 @@ static int filter_prep_groups(struct obd_device *obd) filter->fo_last_objid_files[i] = filp; if (filp->f_dentry->d_inode->i_size == 0) { - if (i == 0 && filter->fo_fsd->fsd_unused != 0) { + if (i == 0 && filter->fo_fsd->lsd_unused != 0) { /* OST conversion, remove sometime post 1.0 */ filter->fo_last_objids[0] = - le64_to_cpu(filter->fo_fsd->fsd_unused); + le64_to_cpu(filter->fo_fsd->lsd_unused); CWARN("saving old objid "LPU64" to LAST_ID\n", filter->fo_last_objids[0]); } else { diff --git a/lustre/obdfilter/filter_internal.h b/lustre/obdfilter/filter_internal.h index 1c30fbc..4b5c27d 100644 --- a/lustre/obdfilter/filter_internal.h +++ b/lustre/obdfilter/filter_internal.h @@ -45,26 +45,6 @@ #define FILTER_GRANT_CHUNK (2ULL*1024*1024) -/* Data stored per server at the head of the last_rcvd file. In le32 order. - * Try to keep this the same as mds_server_data so we might one day merge. */ -struct filter_server_data { - __u8 fsd_uuid[40]; /* server UUID */ - __u64 fsd_unused; /* was fsd_last_objid - don't use for now */ - __u64 fsd_last_transno; /* last completed transaction ID */ - __u64 fsd_mount_count; /* FILTER incarnation number */ - __u32 fsd_feature_compat; /* compatible feature flags */ - __u32 fsd_feature_rocompat;/* read-only compatible feature flags */ - __u32 fsd_feature_incompat;/* incompatible feature flags */ - __u32 fsd_server_size; /* size of server data area */ - __u32 fsd_client_start; /* start of per-client data area */ - __u16 fsd_client_size; /* size of per-client data area */ - __u16 fsd_subdir_count; /* number of subdirectories for objects */ - __u64 fsd_catalog_oid; /* recovery catalog object id */ - __u32 fsd_catalog_ogen; /* recovery catalog inode generation */ - __u8 fsd_peeruuid[40]; /* UUID of MDS associated with this OST */ - __u8 fsd_padding[FILTER_LR_SERVER_SIZE - 140]; -}; - /* Data stored per client in the last_rcvd file. In le32 order. */ struct filter_client_data { __u8 fcd_uuid[40]; /* client UUID */ @@ -107,7 +87,7 @@ int filter_finish_transno(struct obd_export *, struct obd_trans_info *, int rc); __u64 filter_next_id(struct filter_obd *, struct obdo *); __u64 filter_last_id(struct filter_obd *, struct obdo *); int filter_update_server_data(struct obd_device *, struct file *, - struct filter_server_data *, int force_sync); + struct lr_server_data *, int force_sync); int filter_update_last_objid(struct obd_device *, obd_gr, int force_sync); int filter_common_setup(struct obd_device *, obd_count len, void *buf, void *option); @@ -128,8 +108,8 @@ int filter_commitrw(int cmd, struct obd_export *, struct obdo *, int objcount, struct obd_ioobj *, int niocount, struct niobuf_local *, struct obd_trans_info *, int rc); int filter_brw(int cmd, struct obd_export *, struct obdo *, - struct lov_stripe_md *, obd_count oa_bufs, struct brw_page *, - struct obd_trans_info *); + struct lov_stripe_md *, obd_count oa_bufs, struct brw_page *, + struct obd_trans_info *); void flip_into_page_cache(struct inode *inode, struct page *new_page); void filter_free_dio_pages(int objcount, struct obd_ioobj *obj, int niocount, struct niobuf_local *res); diff --git a/lustre/utils/Makefile.am b/lustre/utils/Makefile.am index 4b3f69e..033dcb8 100644 --- a/lustre/utils/Makefile.am +++ b/lustre/utils/Makefile.am @@ -8,52 +8,50 @@ AM_CPPFLAGS=$(LLCPPFLAGS) -DLUSTRE_UTILS=1 LIBPTLCTL := $(top_builddir)/portals/utils/libptlctl.a sbin_scripts = lconf lmc llanalyze llstat.pl llobdstat.pl lactive \ - load_ldap.sh lrun lwizard mount.lustre mkfs.lustre + load_ldap.sh lrun lwizard bin_scripts = lfind lstripe llog_reader if UTILS -rootsbin_SCRIPTS = mount.lustre mkfs.lustre -sbin_PROGRAMS = lctl obdio obdbarrier lload wirecheck wiretest mount.lustre mkfs.lustre +rootsbin_SCRIPTS = +sbin_PROGRAMS = lctl obdio obdbarrier lload wirecheck wiretest mount_lustre mount.lustre mkfs_lustre mkfs.lustre bin_PROGRAMS = lfs llog_reader lib_LIBRARIES = liblustreapi.a sbin_SCRIPTS = $(sbin_scripts) bin_SCRIPTS = $(bin_scripts) endif # UTILS -lctl_LDADD := $(LIBREADLINE) $(LIBPTLCTL) -lctl_DEPENDENCIES := $(LIBPTLCTL) - -lfs_LDADD := $(LIBREADLINE) liblustreapi.a $(LIBPTLCTL) -lfs_DEPENDENCIES := $(LIBPTLCTL) liblustreapi.a - -lload_LDADD := $(LIBREADLINE) $(LIBPTLCTL) -lload_DEPENDENCIES := $(LIBPTLCTL) - -llog_reader_LDADD := $(LIBREADLINE) $(LIBPTLCTL) -llog_reader_DEPENDENCIES := $(LIBPTLCTL) - liblustreapi_a_SOURCES = liblustreapi.c wirecheck_SOURCES = wirecheck.c wirecheck_CPPFLAGS = -DCC="\"$(CC)\"" wiretest_SOURCES = wiretest.c +lctl_LDADD := $(LIBREADLINE) $(LIBPTLCTL) +lctl_DEPENDENCIES := $(LIBPTLCTL) lctl_SOURCES = parser.c obd.c lustre_cfg.c lctl.c parser.h obdctl.h +lload_LDADD := $(LIBREADLINE) $(LIBPTLCTL) +lload_DEPENDENCIES := $(LIBPTLCTL) lload_SOURCES = lload.c + obdio_SOURCES = obdio.c obdiolib.c obdiolib.h obdbarrier_SOURCES = obdbarrier.c obdiolib.c obdiolib.h + +lfs_LDADD := $(LIBREADLINE) liblustreapi.a $(LIBPTLCTL) +lfs_DEPENDENCIES := $(LIBPTLCTL) liblustreapi.a lfs_SOURCES = lfs.c parser.c obd.c -mount_lustre_LDADD = $(LIBREADLINE) $(LIBPTLCTL) +llog_reader_LDADD := $(LIBREADLINE) $(LIBPTLCTL) +llog_reader_DEPENDENCIES := $(LIBPTLCTL) +llog_reader_SOURCES = llog_reader.c + +mount_lustre_LDADD := $(LIBREADLINE) $(LIBPTLCTL) mount_lustre_DEPENDENCIES := $(LIBPTLCTL) mount_lustre_SOURCES = mount_lustre.c -mkfs_lustre_LDADD = $(LIBREADLINE) $(LIBPTLCTL) +mkfs_lustre_LDADD := $(LIBREADLINE) $(LIBPTLCTL) mkfs_lustre_DEPENDENCIES := $(LIBPTLCTL) -mkfs_lustre_SOURCES = mkfs_lustre.c lustre_cfg.c obd.c obdctl.h - -llog_reader_SOURCES = llog_reader.c +mkfs_lustre_SOURCES = parser.c obd.c lustre_cfg.c mkfs_lustre.c parser.h obdctl.h EXTRA_DIST = $(bin_scripts) $(sbin_scripts) diff --git a/lustre/utils/mkfs_lustre.c b/lustre/utils/mkfs_lustre.c index 1cb8276..35d2c32 100644 --- a/lustre/utils/mkfs_lustre.c +++ b/lustre/utils/mkfs_lustre.c @@ -32,7 +32,6 @@ #include #include - #include #include @@ -78,16 +77,16 @@ void usage(FILE *out) "\t\t--configdev=: store configuration info\n" "\t\t\tfor this device on an alternate device\n" "\t\t--failover=\n" + "\t\t--backfstype=: backing fs type (ext3, ldiskfs)\n" "\t\t--device_size=#N(KB):device size \n" "\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--mountopts=: permanent mount options\n" - "\t\t--smfsopts=: smfs format options\n" - "\t\t--ext3opts=: ext3 format options\n" + "\t\t--mountfsoptions=: permanent mount options\n" + "\t\t--mkfsoptions=: 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" + "\t\t--startupwait=: time to wait for other servers to join\n" + "\t\t--reformat: overwrite an existing disk\n" "\t\t--verbose\n"); exit(out != stdout); } @@ -319,8 +318,6 @@ int write_local_files(struct mkfs_opts *mop) lsd.lsd_index = mop->mo_index; fwrite(&lsd, sizeof(lsd), 1, filep); ret = 0; - -out_close: fclose(filep); out_umnt: sprintf(cmd, "umount %s", mntpt); @@ -341,7 +338,7 @@ int make_lustre_backfs(struct mkfs_opts *mop) if (mop->mo_device_sz != 0) { if (mop->mo_device_sz < 8096){ fprintf(stderr, "size of filesystem must be larger " - "than 8MB, but is set to %dKB\n", + "than 8MB, but is set to %ldKB\n", mop->mo_device_sz); return EINVAL; } @@ -369,7 +366,7 @@ int make_lustre_backfs(struct mkfs_opts *mop) if (journal_sz > 400) journal_sz = 400; if (journal_sz) { - sprintf(buf, " -J size=%d", journal_sz); + sprintf(buf, " -J size=%ld", journal_sz); strcat(mop->mo_mkfsopts, buf); } } @@ -388,7 +385,7 @@ int make_lustre_backfs(struct mkfs_opts *mop) else if ((IS_OST(&mop->mo_ldd) && (device_sz > 1000000))) inode_sz = 16384; if (inode_sz > 0) { - sprintf(buf, " -i %d", inode_sz); + sprintf(buf, " -i %ld", inode_sz); strcat(mop->mo_mkfsopts, buf); } } @@ -399,7 +396,7 @@ int make_lustre_backfs(struct mkfs_opts *mop) } else if (mop->mo_ldd.ldd_mount_type == LDD_MT_REISERFS) { long journal_sz = 0; if (journal_sz > 0) { /* FIXME */ - sprintf(buf, " --journal_size %d", journal_sz); + sprintf(buf, " --journal_size %ld", journal_sz); strcat(mop->mo_mkfsopts, buf); } sprintf(mkfs_cmd, "mkreiserfs -ff "); @@ -407,7 +404,7 @@ int make_lustre_backfs(struct mkfs_opts *mop) } else { fprintf(stderr,"unsupported fs type: %d (%s)\n", mop->mo_ldd.ldd_mount_type, - MT_STR(mop->mo_ldd)); + MT_STR(&mop->mo_ldd)); return EINVAL; } @@ -461,7 +458,7 @@ int create_loop_device(struct mkfs_opts *mop) init_loop_base(); - sprintf(cmd, "dd if=/dev/zero bs=1k count=0 seek=%d of=%s", + sprintf(cmd, "dd if=/dev/zero bs=1k count=0 seek=%ld of=%s", mop->mo_device_sz, mop->mo_device); ret = run_command(cmd, cmd_out); if (ret != 0){ @@ -766,7 +763,7 @@ void set_defaults(struct mkfs_opts *mop) mop->mo_hostnid.primary = libcfs_str2nid(hostname); } -static inline badopt(char opt, char *type) +static inline void badopt(char opt, char *type) { fprintf(stderr, "%s: '%c' only valid for %s\n", progname, opt, type); @@ -778,21 +775,21 @@ int main(int argc , char *const argv[]) { struct mkfs_opts mop; static struct option long_opt[] = { + {"backfstype", 1, 0, 'b'}, {"configdev", 1, 0, 'C'}, {"device_size", 1, 0, 'd'}, - {"ext3opts", 1, 0, 'e'}, {"fsname",1, 0, 'n'}, {"failover", 1, 0, 'f'}, - {"forceformat", 0, 0, 'F'}, {"help", 0, 0, 'h'}, {"index", 1, 0, 'I'}, - {"maxwait", 1, 0, 'w'}, {"mdt", 0, 0, 'M'}, {"mgmt", 0, 0, 'G'}, {"mgmtnode", 1, 0, 'm'}, - {"mountopts", 1, 0, 'o'}, + {"mkfsoptions", 1, 0, 'k'}, + {"mountfsoptions", 1, 0, 'o'}, {"ost", 0, 0, 'O'}, - {"smfsopts", 1, 0, 'S'}, + {"reformat", 0, 0, 'r'}, + {"startupwait", 1, 0, 'w'}, {"stripe_count", 1, 0, 'c'}, {"stripe_size", 1, 0, 's'}, {"stripe_index", 1, 0, 'i'}, @@ -800,7 +797,7 @@ 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:o:OS:c:s:i:t:v"; + char *optstring = "b:C:d:n:f:hI:MGm:k:o:Orw:c:s:i:t:v"; char opt; char *mountopts = NULL; int ret = 0; @@ -814,6 +811,17 @@ int main(int argc , char *const argv[]) while ((opt = getopt_long(argc,argv,optstring,long_opt,NULL)) != EOF) { switch (opt) { + case 'b': { + int i = 0; + while (i < LDD_MT_LAST) { + if (strcmp(optarg, mt_str(i)) == 0) { + mop.mo_ldd.ldd_mount_type = i; + break; + } + i++; + } + break; + } case 'C': //FIXME exit(2); @@ -828,20 +836,13 @@ int main(int argc , char *const argv[]) case 'd': mop.mo_device_sz = atol(optarg); break; - case 'e': - if ((mop.mo_ldd.ldd_mount_type == LDD_MT_LDISKFS) || - (mop.mo_ldd.ldd_mount_type == LDD_MT_EXT3)) - strncpy(mop.mo_mkfsopts, optarg, - sizeof(mop.mo_mkfsopts) - 1); - else - badopt(opt, "ext3,ldiskfs"); + case 'k': + strncpy(mop.mo_mkfsopts, optarg, + sizeof(mop.mo_mkfsopts) - 1); break; case 'f': mop.mo_hostnid.backup = libcfs_str2nid(optarg); break; - case 'F': - mop.mo_flags |= MO_FORCEFORMAT; - break; case 'G': mop.mo_ldd.ldd_flags |= LDD_SV_TYPE_MGMT; break; @@ -880,16 +881,15 @@ int main(int argc , char *const argv[]) case 'O': mop.mo_ldd.ldd_flags |= LDD_SV_TYPE_OST; break; + case 'r': + mop.mo_flags |= MO_FORCEFORMAT; + break; case 's': if (IS_MDT(&mop.mo_ldd)) mop.mo_stripe_sz = atol(optarg) * 1024; else badopt(opt, "MDT"); break; - case 'S': - mop.mo_ldd.ldd_mount_type = LDD_MT_SMFS; - strncpy(mop.mo_mkfsopts, optarg, sizeof(mop.mo_mkfsopts) - 1); - break; case 't': mop.mo_timeout = atol(optarg); break; diff --git a/lustre/utils/mount_lustre.c b/lustre/utils/mount_lustre.c index fd654d5..ce04dd9 100644 --- a/lustre/utils/mount_lustre.c +++ b/lustre/utils/mount_lustre.c @@ -195,8 +195,10 @@ init_options(struct lustre_mount_data *lmd) int print_options(struct lustre_mount_data *lmd) { - 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("mgmt primary nid: %s\n", + libcfs_nid2str(lmd->lmd_mgmtnid.primary)); + printf("mgmt backup nid: %s\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); -- 1.8.3.1