X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fllite%2Fsuper.c;h=40ae6238b0eac84768155a9d059b6e34619c8b6e;hp=eb52c7d9c5c263222e63a49d61ec2212d01b6b8e;hb=400b0681017091fab9cef9bd00e0f536e1793dcc;hpb=ec417e23307b411a0a8bc9bf9f78c34d35e42071 diff --git a/lustre/llite/super.c b/lustre/llite/super.c index eb52c7d..40ae623 100644 --- a/lustre/llite/super.c +++ b/lustre/llite/super.c @@ -1,368 +1,602 @@ -/* +/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- + * vim:expandtab:shiftwidth=8:tabstop=8: + * * Lustre Light Super operations * * This code is issued under the GNU General Public License. * See the file COPYING in this distribution * - * Copryright (C) 1996 Peter J. Braam - * Copryright (C) 1999 Stelias Computing Inc. - * Copryright (C) 1999 Seagate Technology Inc. - * Copryright (C) 2001 Mountain View Data, Inc. * Copryright (C) 2002 Cluster File Systems, Inc. - * */ -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include +#define DEBUG_SUBSYSTEM S_LLITE +#include +#include +#include +#include +#include +#include +#include +#include #include -#include -#include -#include - -#define DEBUG_SUBSYSTEM S_LLIGHT +#include -#include -#include -#include +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) kmem_cache_t *ll_file_data_slab; extern struct address_space_operations ll_aops; extern struct address_space_operations ll_dir_aops; struct super_operations ll_super_operations; +extern int ll_recover(struct recovd_data *, int); +extern int ll_commitcbd_setup(struct ll_sb_info *); +extern int ll_commitcbd_cleanup(struct ll_sb_info *); + +extern int rd_dev_uuid(char* page, char **start, off_t off, + int count, int *eof, void *data); + +extern int rd_dev_name(char* page, char **start, off_t off, + int count, int *eof, void *data); + + +extern lprocfs_vars_t status_var_nm_1[]; + static char *ll_read_opt(const char *opt, char *data) { char *value; char *retval; - ENTRY; - - CDEBUG(D_INFO, "option: %s, data %s\n", opt, data); - if ( strncmp(opt, data, strlen(opt)) ) { - EXIT; - return NULL; - } - if ( (value = strchr(data, '=')) == NULL ) { - EXIT; - return NULL; - } + ENTRY; + + CDEBUG(D_SUPER, "option: %s, data %s\n", opt, data); + if ( strncmp(opt, data, strlen(opt)) ) + RETURN(NULL); + if ( (value = strchr(data, '=')) == NULL ) + RETURN(NULL); value++; OBD_ALLOC(retval, strlen(value) + 1); if ( !retval ) { CERROR("out of memory!\n"); - return NULL; + RETURN(NULL); } - + memcpy(retval, value, strlen(value)+1); CDEBUG(D_SUPER, "Assigned option: %s, value %s\n", opt, retval); - EXIT; - return retval; + RETURN(retval); } -static void ll_options(char *options, char **dev, char **vers) +static int ll_set_opt(const char *opt, char *data, int fl) +{ + ENTRY; + + CDEBUG(D_SUPER, "option: %s, data %s\n", opt, data); + if ( strncmp(opt, data, strlen(opt)) ) + RETURN(0); + else + RETURN(fl); +} + +static void ll_options(char *options, char **ost, char **mds, int *flags) { char *this_char; - ENTRY; + ENTRY; - if (!options) { - EXIT; + if (!options) { + EXIT; return; - } + } for (this_char = strtok (options, ","); this_char != NULL; this_char = strtok (NULL, ",")) { - CDEBUG(D_INFO, "this_char %s\n", this_char); - if ( (!*dev && (*dev = ll_read_opt("device", this_char)))|| - (!*vers && (*vers = ll_read_opt("version", this_char))) ) + CDEBUG(D_SUPER, "this_char %s\n", this_char); + if ( (!*ost && (*ost = ll_read_opt("osc", this_char)))|| + (!*mds && (*mds = ll_read_opt("mdc", this_char)))|| + (!(*flags & LL_SBI_NOLCK) && ((*flags) = (*flags) | + ll_set_opt("nolock", this_char, LL_SBI_NOLCK))) ) continue; - } - EXIT; + EXIT; } -static struct super_block * ll_read_super(struct super_block *sb, - void *data, int silent) +#ifndef log2 +#define log2(n) ffz(~(n)) +#endif + +static struct super_block * ll_read_super(struct super_block *sb, + void *data, int silent) { - struct inode *root = 0; + struct inode *root = 0; + struct obd_device *obd; struct ll_sb_info *sbi; - char *device = NULL; - char *version = NULL; - int connected = 0; - int devno; + char *osc = NULL; + char *mdc = NULL; int err; - struct ptlrpc_request *request = NULL; + struct ll_fid rootfid; + struct obd_statfs osfs; + struct ptlrpc_request *request = NULL; + struct ptlrpc_connection *mdc_conn; + struct ll_read_inode2_cookie lic; + class_uuid_t uuid; + + + /* Lprocfs variables */ + char mnt_name[100]; + char uuid_name[100]; + lprocfs_vars_t d_vars[3]; + + ENTRY; - MOD_INC_USE_COUNT; - - OBD_ALLOC(sbi, sizeof(*sbi)); - if (!sbi) { - EXIT; - return NULL; - } - memset(sbi, 0, sizeof(*sbi)); - sb->u.generic_sbp = (struct ll_sb_info *) sbi; - - ll_options(data, &device, &version); - - if ( !device ) { - CERROR("no device\n"); - sb = NULL; - goto ERR; + MOD_INC_USE_COUNT; + + OBD_ALLOC(sbi, sizeof(*sbi)); + if (!sbi) { + MOD_DEC_USE_COUNT; + RETURN(NULL); } - devno = simple_strtoul(device, NULL, 0); - if ( devno >= MAX_OBD_DEVICES ) { - CERROR("device of %s too high\n", device); - sb = NULL; - goto ERR; - } - - sbi->ll_conn.oc_dev = &obd_dev[devno]; - err = obd_connect(&sbi->ll_conn); - if ( err ) { - CERROR("cannot connect to %s\n", device); - sb = NULL; - goto ERR; + INIT_LIST_HEAD(&sbi->ll_conn_chain); + generate_random_uuid(uuid); + class_uuid_unparse(uuid, sbi->ll_sb_uuid); + + sb->u.generic_sbp = sbi; + + ll_options(data, &osc, &mdc, &sbi->ll_flags); + + if (!osc) { + CERROR("no osc\n"); + GOTO(out_free, sb = NULL); + } + + if (!mdc) { + CERROR("no mdc\n"); + GOTO(out_free, sb = NULL); + } + + obd = class_uuid2obd(mdc); + if (!obd) { + CERROR("MDC %s: not setup or attached\n", mdc); + GOTO(out_free, sb = NULL); + } + + err = obd_connect(&sbi->ll_mdc_conn, obd, sbi->ll_sb_uuid, + ptlrpc_recovd, ll_recover); + if (err) { + CERROR("cannot connect to %s: rc = %d\n", mdc, err); + GOTO(out_free, sb = NULL); + } + +#warning Peter: is this the right place to raise the connection level? + mdc_conn = sbi2mdc(sbi)->cl_import.imp_connection; + mdc_conn->c_level = LUSTRE_CONN_FULL; + list_add(&mdc_conn->c_sb_chain, &sbi->ll_conn_chain); + + obd = class_uuid2obd(osc); + if (!obd) { + CERROR("OSC %s: not setup or attached\n", osc); + GOTO(out_mdc, sb = NULL); + } + + err = obd_connect(&sbi->ll_osc_conn, obd, sbi->ll_sb_uuid, + ptlrpc_recovd, ll_recover); + if (err) { + CERROR("cannot connect to %s: rc = %d\n", osc, err); + GOTO(out_mdc, sb = NULL); + } + + err = mdc_getstatus(&sbi->ll_mdc_conn, &rootfid); + if (err) { + CERROR("cannot mds_connect: rc = %d\n", err); + GOTO(out_mdc, sb = NULL); } - connected = 1; - - /* the first parameter should become an mds device no */ - err = ptlrpc_connect_client(-1, "mds", - MDS_REQUEST_PORTAL, - MDC_REPLY_PORTAL, - mds_pack_req, - mds_unpack_rep, - &sbi->ll_mds_client); - - if (err) { - CERROR("cannot find MDS\n"); - sb = NULL; - goto ERR; - } - sbi->ll_super = sb; - sbi->ll_rootino = 2; - - sb->s_maxbytes = 1LL << 36; - sb->s_blocksize = PAGE_SIZE; - sb->s_blocksize_bits = (unsigned char)PAGE_SHIFT; + CDEBUG(D_SUPER, "rootfid "LPU64"\n", rootfid.id); + sbi->ll_rootino = rootfid.id; + + memset(&osfs, 0, sizeof(osfs)); + err = obd_statfs(&sbi->ll_mdc_conn, &osfs); + sb->s_blocksize = osfs.os_bsize; + sb->s_blocksize_bits = log2(osfs.os_bsize); sb->s_magic = LL_SUPER_MAGIC; + sb->s_maxbytes = (1ULL << (32 + 9)) - osfs.os_bsize; + sb->s_op = &ll_super_operations; /* make root inode */ - err = mdc_getattr(&sbi->ll_mds_client, sbi->ll_rootino, S_IFDIR, - OBD_MD_FLNOTOBD|OBD_MD_FLBLOCKS, &request); + err = mdc_getattr(&sbi->ll_mdc_conn, sbi->ll_rootino, S_IFDIR, + OBD_MD_FLNOTOBD|OBD_MD_FLBLOCKS, 0, &request); if (err) { - CERROR("mdc_getattr failed for root %d\n", err); - sb = NULL; - goto ERR; + CERROR("mdc_getattr failed for root: rc = %d\n", err); + GOTO(out_request, sb = NULL); } - root = iget4(sb, sbi->ll_rootino, NULL, request->rq_rep.mds); + /* initialize committed transaction callback daemon */ + spin_lock_init(&sbi->ll_commitcbd_lock); + init_waitqueue_head(&sbi->ll_commitcbd_waitq); + init_waitqueue_head(&sbi->ll_commitcbd_ctl_waitq); + sbi->ll_commitcbd_flags = 0; + err = ll_commitcbd_setup(sbi); + if (err) { + CERROR("failed to start commit callback daemon: rc = %d\n",err); + GOTO(out_request, sb = NULL); + } + + lic.lic_body = lustre_msg_buf(request->rq_repmsg, 0); + lic.lic_lmm = NULL; + LASSERT(sbi->ll_rootino != 0); + root = iget4(sb, sbi->ll_rootino, NULL, &lic); + if (root) { - sb->s_root = d_alloc_root(root); - } else { - CERROR("lustre_light: bad iget4 for root\n"); - sb = NULL; - goto ERR; - } - -ERR: - ptlrpc_free_req(request); - if (device) - OBD_FREE(device, strlen(device) + 1); - if (version) - OBD_FREE(version, strlen(version) + 1); - if (!sb && connected) - obd_disconnect(&sbi->ll_conn); - - if (!sb && root) { - iput(root); + sb->s_root = d_alloc_root(root); + } else { + CERROR("lustre_lite: bad iget4 for root\n"); + GOTO(out_cdb, sb = NULL); + } + + ptlrpc_req_finished(request); + request = NULL; + + + /* Register this mount instance with LProcFS */ + + snprintf(mnt_name, 100, "mount_%s", sbi->ll_sb_uuid); + sbi->ll_mnt_root=lprocfs_reg_mnt(mnt_name); + if(!sbi->ll_mnt_root) + goto out_dev; + + /* Add the static configuration info */ + lprocfs_add_vars(sbi->ll_mnt_root, (lprocfs_vars_t*)status_var_nm_1, + (void*)sb); + + /* Add the dynamic configuration stuff */ + /* MDC */ + obd = class_uuid2obd(mdc); + + /* Reuse mnt_name */ + + sprintf(mnt_name, "status/%s/common_name", obd->obd_type->typ_name); + + memset(d_vars, 0, sizeof(d_vars)); + d_vars[0].read_fptr=rd_dev_name; + d_vars[0].write_fptr=0; + d_vars[0].name=(char*)mnt_name; + + memset(uuid_name, '\0', strlen(uuid_name)); + sprintf(uuid_name, "status/%s/uuid", obd->obd_type->typ_name); + d_vars[1].read_fptr=rd_dev_uuid; + d_vars[1].write_fptr=0; + d_vars[1].name=(char*)uuid_name; + + err=lprocfs_add_vars(sbi->ll_mnt_root, (lprocfs_vars_t*)d_vars, + (void*)obd); + if (err) { + CDEBUG(D_OTHER, "Unable to add fs proc dynamic variables"); } - if (!sb) - MOD_DEC_USE_COUNT; - EXIT; - return sb; + /* OSC or LOV*/ + obd = class_uuid2obd(osc); + /* Reuse mnt_name */ + memset(mnt_name, '\0', strlen(mnt_name)); + sprintf(mnt_name, "status/%s/common_name", obd->obd_type->typ_name); + + memset(d_vars, 0, sizeof(d_vars)); + d_vars[0].read_fptr=rd_dev_name; + d_vars[0].write_fptr=0; + d_vars[0].name=(char*)mnt_name; + + memset(uuid_name, '\0', strlen(uuid_name)); + sprintf(uuid_name, "status/%s/uuid", obd->obd_type->typ_name); + d_vars[1].read_fptr=rd_dev_uuid; + d_vars[1].write_fptr=0; + d_vars[1].name=(char*)uuid_name; + + err=lprocfs_add_vars(sbi->ll_mnt_root, (lprocfs_vars_t*)d_vars, + (void*)obd); + if (err) { + CDEBUG(D_OTHER, "Unable to add fs proc dynamic variables"); + } +out_dev: + if (mdc) + OBD_FREE(mdc, strlen(mdc) + 1); + if (osc) + OBD_FREE(osc, strlen(osc) + 1); + + RETURN(sb); + +out_cdb: + ll_commitcbd_cleanup(sbi); +out_request: + ptlrpc_req_finished(request); + obd_disconnect(&sbi->ll_osc_conn); +out_mdc: + obd_disconnect(&sbi->ll_mdc_conn); +out_free: + OBD_FREE(sbi, sizeof(*sbi)); + + MOD_DEC_USE_COUNT; + goto out_dev; } /* ll_read_super */ static void ll_put_super(struct super_block *sb) { - struct ll_sb_info *sbi = sb->u.generic_sbp; + struct ll_sb_info *sbi = ll_s2sbi(sb); + struct ll_fid rootfid; ENTRY; - obd_disconnect(&sbi->ll_conn); - OBD_FREE(sb->u.generic_sbp, sizeof(struct ll_sb_info)); + + list_del(&sbi->ll_conn_chain); + ll_commitcbd_cleanup(sbi); + obd_disconnect(&sbi->ll_osc_conn); + + /* NULL request to force sync on the MDS, and get the last_committed + * value to flush remaining RPCs from the sending queue on client. + * + * XXX This should be an mdc_sync() call to sync the whole MDS fs, + * which we can call for other reasons as well. + */ + mdc_getstatus(&sbi->ll_mdc_conn, &rootfid); + + lprocfs_dereg_mnt(sbi->ll_mnt_root); + obd_disconnect(&sbi->ll_mdc_conn); + OBD_FREE(sbi, sizeof(*sbi)); + MOD_DEC_USE_COUNT; EXIT; } /* ll_put_super */ +static void ll_clear_inode(struct inode *inode) +{ + struct ll_sb_info *sbi = ll_i2sbi(inode); + int rc; + ENTRY; + + rc = mdc_cancel_unused(&sbi->ll_mdc_conn, inode, LDLM_FL_NO_CALLBACK); + if (rc < 0) { + CERROR("obd_cancel_unused: %d\n", rc); + /* XXX FIXME do something dramatic */ + } + + if (atomic_read(&inode->i_count) == 0) { + struct ll_inode_info *lli = ll_i2info(inode); + struct lov_stripe_md *lsm = lli->lli_smd; + char *symlink_name = lli->lli_symlink_name; + + if (lsm) { + OBD_FREE(lsm, ll_ost_easize(inode->i_sb)); + lli->lli_smd = NULL; + } + if (symlink_name) { + OBD_FREE(symlink_name, strlen(symlink_name) + 1); + lli->lli_symlink_name = NULL; + } + } + + EXIT; +} -extern inline struct obdo * ll_oa_from_inode(struct inode *inode, int valid); static void ll_delete_inode(struct inode *inode) { - if (S_ISREG(inode->i_mode)) { - int err; - struct obdo *oa; - oa = ll_oa_from_inode(inode, OBD_MD_FLNOTOBD); - if (!oa) { - CERROR("no memory\n"); - } - - err = obd_destroy(ll_i2obdconn(inode), oa); - CDEBUG(D_INODE, "obd destroy of %Ld error %d\n", - oa->o_id, err); - obdo_free(oa); - } - - clear_inode(inode); + ENTRY; + if (S_ISREG(inode->i_mode)) { + int err; + struct obdo *oa; + struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd; + + if (!lsm) + GOTO(out, -EINVAL); + + if (lsm->lsm_object_id == 0) { + CERROR("This really happens\n"); + /* No obdo was ever created */ + GOTO(out, 0); + } + + oa = obdo_alloc(); + if (oa == NULL) + GOTO(out, -ENOMEM); + + oa->o_id = lsm->lsm_object_id; + oa->o_easize = ll_mds_easize(inode->i_sb); + oa->o_mode = inode->i_mode; + oa->o_valid = OBD_MD_FLID | OBD_MD_FLEASIZE | OBD_MD_FLTYPE; + + err = obd_destroy(ll_i2obdconn(inode), oa, lsm); + obdo_free(oa); + CDEBUG(D_SUPER, "obd destroy of objid "LPX64" error %d\n", + lsm->lsm_object_id, err); + } +out: + clear_inode(inode); + EXIT; } -/* like inode_setattr, but doesn't mark the inode dirty */ +/* like inode_setattr, but doesn't mark the inode dirty */ static int ll_attr2inode(struct inode * inode, struct iattr * attr, int trunc) { - unsigned int ia_valid = attr->ia_valid; - int error = 0; - - if ((ia_valid & ATTR_SIZE) && trunc ) { - error = vmtruncate(inode, attr->ia_size); - if (error) - goto out; - } else if (ia_valid & ATTR_SIZE) { - inode->i_size = attr->ia_size; - } - - if (ia_valid & ATTR_UID) - inode->i_uid = attr->ia_uid; - if (ia_valid & ATTR_GID) - inode->i_gid = attr->ia_gid; - if (ia_valid & ATTR_ATIME) - inode->i_atime = attr->ia_atime; - if (ia_valid & ATTR_MTIME) - inode->i_mtime = attr->ia_mtime; - if (ia_valid & ATTR_CTIME) - inode->i_ctime = attr->ia_ctime; - if (ia_valid & ATTR_MODE) { - inode->i_mode = attr->ia_mode; - if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) - inode->i_mode &= ~S_ISGID; - } + unsigned int ia_valid = attr->ia_valid; + int error = 0; + + if ((ia_valid & ATTR_SIZE) && trunc) { + error = vmtruncate(inode, attr->ia_size); + if (error) + goto out; + } else if (ia_valid & ATTR_SIZE) + inode->i_size = attr->ia_size; + + if (ia_valid & ATTR_UID) + inode->i_uid = attr->ia_uid; + if (ia_valid & ATTR_GID) + inode->i_gid = attr->ia_gid; + if (ia_valid & ATTR_ATIME) + inode->i_atime = attr->ia_atime; + if (ia_valid & ATTR_MTIME) + inode->i_mtime = attr->ia_mtime; + if (ia_valid & ATTR_CTIME) + inode->i_ctime = attr->ia_ctime; + if (ia_valid & ATTR_MODE) { + inode->i_mode = attr->ia_mode; + if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) + inode->i_mode &= ~S_ISGID; + } out: - return error; + return error; } int ll_inode_setattr(struct inode *inode, struct iattr *attr, int do_trunc) { - struct ptlrpc_request *request; + struct ptlrpc_request *request = NULL; struct ll_sb_info *sbi = ll_i2sbi(inode); - int err; + int err; ENTRY; - /* change incore inode */ - ll_attr2inode(inode, attr, do_trunc); + /* change incore inode */ + ll_attr2inode(inode, attr, do_trunc); - err = mdc_setattr(&sbi->ll_mds_client, inode, attr, &request); + err = mdc_setattr(&sbi->ll_mdc_conn, inode, attr, &request); if (err) CERROR("mdc_setattr fails (%d)\n", err); - ptlrpc_free_req(request); + ptlrpc_req_finished(request); - EXIT; - return err; + RETURN(err); } int ll_setattr(struct dentry *de, struct iattr *attr) { - return ll_inode_setattr(de->d_inode, attr, 1); + int rc = inode_change_ok(de->d_inode, attr); + + if (rc) + return rc; + + return ll_inode_setattr(de->d_inode, attr, 1); } -static int ll_statfs(struct super_block *sb, struct statfs *buf) +static int ll_statfs(struct super_block *sb, struct statfs *sfs) { - struct statfs tmp; - int err; - + struct ll_sb_info *sbi = ll_s2sbi(sb); + struct obd_statfs osfs; + int rc; ENTRY; - err = obd_statfs(ID(sb), &tmp); - if ( err ) { - CERROR("obd_statfs fails (%d)\n", err); - return err; + memset(sfs, 0, sizeof(*sfs)); + rc = obd_statfs(&sbi->ll_mdc_conn, &osfs); + statfs_unpack(sfs, &osfs); + if (rc) + CERROR("mdc_statfs fails: rc = %d\n", rc); + else + CDEBUG(D_SUPER, "mdc_statfs shows blocks "LPU64"/"LPU64 + " objects "LPU64"/"LPU64"\n", + osfs.os_bavail, osfs.os_blocks, + osfs.os_ffree, osfs.os_files); + + /* temporary until mds_statfs returns statfs info for all OSTs */ + if (!rc) { + rc = obd_statfs(&sbi->ll_osc_conn, &osfs); + if (rc) { + CERROR("obd_statfs fails: rc = %d\n", rc); + GOTO(out, rc); + } + CDEBUG(D_SUPER, "obd_statfs shows blocks "LPU64"/"LPU64 + " objects "LPU64"/"LPU64"\n", + osfs.os_bavail, osfs.os_blocks, + osfs.os_ffree, osfs.os_files); + + while (osfs.os_blocks > ~0UL) { + sfs->f_bsize <<= 1; + + osfs.os_blocks >>= 1; + osfs.os_bfree >>= 1; + osfs.os_bavail >>= 1; + } + sfs->f_blocks = osfs.os_blocks; + sfs->f_bfree = osfs.os_bfree; + sfs->f_bavail = osfs.os_bavail; + if (osfs.os_ffree < (__u64)sfs->f_ffree) + sfs->f_ffree = osfs.os_ffree; } - memcpy(buf, &tmp, sizeof(*buf)); - CDEBUG(D_SUPER, "statfs returns avail %ld\n", tmp.f_bavail); - EXIT; - return err; +out: + RETURN(rc); } -static void inline ll_to_inode(struct inode *dst, struct mds_rep *rep) +void ll_update_inode(struct inode *inode, struct mds_body *body) { - struct ll_inode_info *ii = - (struct ll_inode_info *) &dst->u.generic_ip; - - /* core attributes first */ - if ( rep->valid & OBD_MD_FLID ) - dst->i_ino = rep->ino; - if ( rep->valid & OBD_MD_FLATIME ) - dst->i_atime = rep->atime; - if ( rep->valid & OBD_MD_FLMTIME ) - dst->i_mtime = rep->mtime; - if ( rep->valid & OBD_MD_FLCTIME ) - dst->i_ctime = rep->ctime; - if ( rep->valid & OBD_MD_FLSIZE ) - dst->i_size = rep->size; - if ( rep->valid & OBD_MD_FLMODE ) - dst->i_mode = rep->mode; - if ( rep->valid & OBD_MD_FLUID ) - dst->i_uid = rep->uid; - if ( rep->valid & OBD_MD_FLGID ) - dst->i_gid = rep->gid; - if ( rep->valid & OBD_MD_FLFLAGS ) - dst->i_flags = rep->flags; - if ( rep->valid & OBD_MD_FLNLINK ) - dst->i_nlink = rep->nlink; - if ( rep->valid & OBD_MD_FLGENER ) - dst->i_generation = rep->generation; - - /* this will become more elaborate for striping etc */ - if (rep->valid & OBD_MD_FLOBJID) - ii->lli_objid = rep->objid; -#if 0 - - if (obdo_has_inline(oa)) { - if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || - S_ISFIFO(inode->i_mode)) { - obd_rdev rdev = *((obd_rdev *)oa->o_inline); - CDEBUG(D_INODE, - "copying device %x from obdo to inode\n", rdev); - init_special_inode(inode, inode->i_mode, rdev); - } else { - CDEBUG(D_INFO, "copying inline from obdo to inode\n"); - memcpy(oinfo->lli_inline, oa->o_inline, OBD_INLINESZ); - } - oinfo->lli_flags |= OBD_FL_INLINEDATA; - } -#endif -} /* ll_to_inode */ + if (body->valid & OBD_MD_FLID) + inode->i_ino = body->ino; + if (body->valid & OBD_MD_FLATIME) + inode->i_atime = body->atime; + if (body->valid & OBD_MD_FLMTIME) + inode->i_mtime = body->mtime; + if (body->valid & OBD_MD_FLCTIME) + inode->i_ctime = body->ctime; + if (body->valid & OBD_MD_FLMODE) + inode->i_mode = (inode->i_mode & S_IFMT)|(body->mode & ~S_IFMT); + if (body->valid & OBD_MD_FLTYPE) + inode->i_mode = (inode->i_mode & ~S_IFMT)|(body->mode & S_IFMT); + if (body->valid & OBD_MD_FLUID) + inode->i_uid = body->uid; + if (body->valid & OBD_MD_FLGID) + inode->i_gid = body->gid; + if (body->valid & OBD_MD_FLFLAGS) + inode->i_flags = body->flags; + if (body->valid & OBD_MD_FLNLINK) + inode->i_nlink = body->nlink; + if (body->valid & OBD_MD_FLGENER) + inode->i_generation = body->generation; + if (body->valid & OBD_MD_FLRDEV) + inode->i_rdev = body->rdev; + if (body->valid & OBD_MD_FLSIZE) + inode->i_size = body->size; +} -static inline void ll_read_inode2(struct inode *inode, void *opaque) +static void ll_read_inode2(struct inode *inode, void *opaque) { - struct mds_rep *rep = opaque; - - ENTRY; - ll_to_inode(inode, rep); + struct ll_read_inode2_cookie *lic = opaque; + struct mds_body *body = lic->lic_body; + struct ll_inode_info *lli = ll_i2info(inode); + ENTRY; + + sema_init(&lli->lli_open_sem, 1); + + /* core attributes first */ + ll_update_inode(inode, body); + + //if (body->valid & OBD_MD_FLEASIZE) + if (lic && lic->lic_lmm) { + struct lov_mds_md *lmm = lic->lic_lmm; + int size; + + /* XXX This should probably not be an error in the future, + * when we allow LOV OSTs to be added. + */ + if (lmm->lmm_easize != ll_mds_easize(inode->i_sb)) { + CERROR("Striping metadata size error %ld\n", + inode->i_ino); + LBUG(); + } + size = ll_ost_easize(inode->i_sb); + OBD_ALLOC(lli->lli_smd, size); + if (!lli->lli_smd) { + CERROR("No memory for %d\n", size); + LBUG(); + } + lov_unpackmd(lli->lli_smd, lmm); + } else { + lli->lli_smd = NULL; + } + + /* Get the authoritative file size */ + if (lli->lli_smd && (inode->i_mode & S_IFREG)) { + int rc; + + rc = ll_file_size(inode, lli->lli_smd); + if (rc) { + CERROR("ll_file_size: %d\n", rc); + /* FIXME: need to somehow prevent inode creation */ + LBUG(); + } + } /* OIDEBUG(inode); */ @@ -373,55 +607,92 @@ static inline void ll_read_inode2(struct inode *inode, void *opaque) EXIT; } else if (S_ISDIR(inode->i_mode)) { inode->i_op = &ll_dir_inode_operations; - inode->i_fop = &ll_dir_operations; + inode->i_fop = &ll_dir_operations; inode->i_mapping->a_ops = &ll_dir_aops; EXIT; } else if (S_ISLNK(inode->i_mode)) { - inode->i_op = &ll_fast_symlink_inode_operations; + inode->i_op = &ll_fast_symlink_inode_operations; EXIT; } else { - init_special_inode(inode, inode->i_mode, - ((int *)ll_i2info(inode)->lli_inline)[0]); + init_special_inode(inode, inode->i_mode, inode->i_rdev); + EXIT; + } +} + +static inline void invalidate_request_list(struct list_head *req_list) +{ + struct list_head *tmp, *n; + list_for_each_safe(tmp, n, req_list) { + struct ptlrpc_request *req = + list_entry(tmp, struct ptlrpc_request, rq_list); + CERROR("invalidating req xid "LPD64" op %d to %s:%d\n", + (unsigned long long)req->rq_xid, req->rq_reqmsg->opc, + req->rq_connection->c_remote_uuid, + req->rq_import->imp_client->cli_request_portal); + req->rq_flags |= PTL_RPC_FL_ERR; + wake_up(&req->rq_wait_for_rep); } +} - EXIT; - return; +void ll_umount_begin(struct super_block *sb) +{ + struct ll_sb_info *sbi = ll_s2sbi(sb); + struct list_head *ctmp; + + ENTRY; + + list_for_each(ctmp, &sbi->ll_conn_chain) { + struct ptlrpc_connection *conn; + conn = list_entry(ctmp, struct ptlrpc_connection, c_sb_chain); + + spin_lock(&conn->c_lock); + /* XXX should just be dealing with imports, probably through + * XXX iocontrol, need next-gen recovery! */ + conn->c_flags |= CONN_INVALID; + invalidate_request_list(&conn->c_sending_head); + invalidate_request_list(&conn->c_delayed_head); + spin_unlock(&conn->c_lock); + } + + EXIT; } /* exported operations */ struct super_operations ll_super_operations = { - read_inode2: ll_read_inode2, + read_inode2: ll_read_inode2, + clear_inode: ll_clear_inode, delete_inode: ll_delete_inode, put_super: ll_put_super, - // statfs: ll_statfs + statfs: ll_statfs, + umount_begin: ll_umount_begin }; -struct file_system_type lustre_light_fs_type = { - "lustre_light", 0, ll_read_super, NULL +struct file_system_type lustre_lite_fs_type = { + "lustre_lite", 0, ll_read_super, NULL }; -static int __init init_lustre_light(void) +static int __init init_lustre_lite(void) { - printk(KERN_INFO "Lustre Light 0.0.1, braam@clusterfs.com\n"); - ll_file_data_slab = kmem_cache_create("ll_file_data", - sizeof(struct ll_file_data), 0, - SLAB_HWCACHE_ALIGN, NULL, NULL); - if (ll_file_data_slab == NULL) - return -ENOMEM; - - return register_filesystem(&lustre_light_fs_type); + printk(KERN_INFO "Lustre Lite 0.5.14, info@clusterfs.com\n"); + ll_file_data_slab = kmem_cache_create("ll_file_data", + sizeof(struct ll_file_data), 0, + SLAB_HWCACHE_ALIGN, NULL, NULL); + if (ll_file_data_slab == NULL) + return -ENOMEM; + return register_filesystem(&lustre_lite_fs_type); } -static void __exit exit_lustre_light(void) +static void __exit exit_lustre_lite(void) { - unregister_filesystem(&lustre_light_fs_type); - kmem_cache_destroy(ll_file_data_slab); + unregister_filesystem(&lustre_lite_fs_type); + kmem_cache_destroy(ll_file_data_slab); } -MODULE_AUTHOR("Peter J. Braam "); -MODULE_DESCRIPTION("Lustre Light Client File System v1.0"); +MODULE_AUTHOR("Cluster File Systems, Inc. "); +MODULE_DESCRIPTION("Lustre Lite Client File System v1.0"); MODULE_LICENSE("GPL"); -module_init(init_lustre_light); -module_exit(exit_lustre_light); +module_init(init_lustre_lite); +module_exit(exit_lustre_lite); +#endif