From 2ccf6c9c0919e9a7459aa35c95d4ade6f57a26d5 Mon Sep 17 00:00:00 2001 From: braam Date: Sat, 19 Oct 2002 16:09:43 +0000 Subject: [PATCH] ONLY UPDATE IF YOU NEED THIS (i.e. Andreas probably will) - more fixes for 2.5 builds, much overlap with Andreas' check in from yesterday. - add vfs_inode to Lustre inode info: for 2.5 this makes this the whole inode. - two versions of intent_release: Robert's and the new one for 2.5 - Robert's patch - so this may break some stuff, we'll sort that out. - convert device numbers - small fixes to make thread handling compatible with 2.5 - always compile super25.c and super.c; the contents is conditional on the version --- lustre/Makefile.am | 5 +- lustre/configure.in | 11 +- lustre/include/linux/lustre_lite.h | 55 ++- lustre/include/linux/obd_class.h | 9 +- lustre/include/linux/obd_support.h | 14 +- lustre/ldlm/ldlm_test.c | 4 + lustre/lib/mds_updates.c | 6 +- lustre/llite/Makefile.am | 2 +- lustre/llite/commit_callback.c | 2 +- lustre/llite/dcache.c | 7 +- lustre/llite/dir.c | 8 +- lustre/llite/file.c | 2 + lustre/llite/namei.c | 52 +-- lustre/llite/rw.c | 3 + lustre/llite/super.c | 3 + lustre/llite/super25.c | 677 +++++++++++++++++++++++++++++++++++++ lustre/llite/symlink.c | 2 +- lustre/obdclass/lprocfs.c | 1 + lustre/obdfilter/Makefile.am | 3 - lustre/obdfilter/filter.c | 7 +- lustre/ptlrpc/recovd.c | 5 + lustre/ptlrpc/service.c | 4 + 22 files changed, 824 insertions(+), 58 deletions(-) create mode 100644 lustre/llite/super25.c diff --git a/lustre/Makefile.am b/lustre/Makefile.am index 541be49..4ba0e0d 100644 --- a/lustre/Makefile.am +++ b/lustre/Makefile.am @@ -6,8 +6,9 @@ AUTOMAKE_OPTIONS = foreign # NOTE: keep extN before mds -SUBDIRS = lov utils obdclass ldlm ptlrpc llite lib obdecho mdc osc extN -SUBDIRS+= mds ost tests obdfilter doc scripts +SUBDIRS = lov utils obdclass ldlm ptlrpc llite lib obdecho mdc osc +SUBDIRS+= mds ost tests obdfilter doc scripts extN + DIST_SUBDIRS = $(SUBDIRS) EXTRA_DIST = BUGS FDL Rules include patches archdep.m4 diff --git a/lustre/configure.in b/lustre/configure.in index 511d389..d8e2ccc 100644 --- a/lustre/configure.in +++ b/lustre/configure.in @@ -50,17 +50,14 @@ CPPFLAGS="$KINCFLAGS $ARCHCPPFLAGS" portalsdir_def='$(top_srcdir)/../portals' AC_ARG_WITH(portals, [ --with-portals=[path] set path to Portals source (default=../portals)], enable_portalsdir=$withval) -AC_ARG_ENABLE(portalsdir, [ --enable-portalsdir=[path] (deprecated) set path to Portals source (default=../portals)],, enable_portalsdir=$portalsdir_def) +AC_ARG_ENABLE(portalsdir, [ --enable-portalsdir=[path] (deprecated) set path to Portals source (default=$(top_srcdir)/../portals)],, enable_portalsdir=$portalsdir_def) PORTALS=$enable_portalsdir AC_SUBST(PORTALS) +portalslib_def='$(top_srcdir)/../portals' AC_ARG_WITH(portalslib, [ --with-portalslib=[path] set path to Portals library (default=../portals/linux/utils)], enable_portalslib=$withval) -AC_ARG_ENABLE(portalslib, [ --enable-portalslib=[path] (deprecated) set path to Portals lib (default=../portals/linux/utils)],, enable_portalslib='') -if test -z "$enable_portalslib"; then - PORTALSLIB=${PORTALS}/linux/utils -else - PORTALSLIB=${enable_portalslib} -fi +AC_ARG_ENABLE(portalslib, [ --enable-portalslib=[path] (deprecated) set path to Portals lib (default=../portals/linux/utils)],, enable_portalslib=$portalslib_def) +PORTALSLIB=$enable_portalslib/linux/utils AC_SUBST(PORTALSLIB) AC_MSG_CHECKING(if make dep has been run in kernel source) diff --git a/lustre/include/linux/lustre_lite.h b/lustre/include/linux/lustre_lite.h index 50f2c34..83f3e27 100644 --- a/lustre/include/linux/lustre_lite.h +++ b/lustre/include/linux/lustre_lite.h @@ -50,8 +50,19 @@ struct ll_inode_info { struct lustre_handle lli_intent_lock_handle; struct semaphore lli_open_sem; __u32 lli_mount_epoch; +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) + struct inode lli_vfs_inode; +#endif }; +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) +static inline struct ll_inode_info *LL_I(struct inode *inode) +{ + return container_of(inode, struct ll_inode_info, lli_vfs_inode); +} +#endif + + #define LL_SUPER_MAGIC 0x0BD00BD0 #define LL_COMMITCBD_STOPPING 0x1 @@ -149,9 +160,51 @@ int ll_lock(struct inode *dir, struct dentry *dentry, int ll_unlock(__u32 mode, struct lustre_handle *lockh); /* dcache.c */ -void ll_intent_release(struct dentry *de); +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) +void ll_intent_release(struct nameidata *); +#else +void ll_intent_release(struct dentry *, struct lookup_intent *); +#endif int ll_set_dd(struct dentry *de); +/**** + +I originally implmented these as functions, then realized a macro +would be more helpful for debugging, so the CDEBUG messages show +the current calling function. The orignal functions are in llite/dcache.c + +int ll_save_intent(struct dentry * de, struct lookup_intent * it); +struct lookup_intent * ll_get_intent(struct dentry * de); +****/ + +#define LL_SAVE_INTENT(de, it) \ +do { \ + LASSERT(ll_d2d(de) != NULL); \ + \ + down(&ll_d2d(de)->lld_it_sem); \ + de->d_it = it; \ + CDEBUG(D_DENTRY, "D_IT DOWN dentry %p fsdata %p intent: %s sem %d\n", \ + de, ll_d2d(de), ldlm_it2str(de->d_it->it_op), \ + atomic_read(&(ll_d2d(de)->lld_it_sem.count))); \ + \ +} while(0) + +#define LL_GET_INTENT(de, it) \ +do { \ + it = de->d_it; \ + \ + LASSERT(ll_d2d(de) != NULL); \ + \ + CDEBUG(D_DENTRY, "D_IT UP dentry %p fsdata %p intent: %s\n", de, ll_d2d(de), \ + ldlm_it2str(de->d_it->it_op)); \ + de->d_it = NULL; \ + up(&ll_d2d(de)->lld_it_sem); \ + \ + \ +} while(0) + + + /* dir.c */ extern struct file_operations ll_dir_operations; extern struct inode_operations ll_dir_inode_operations; diff --git a/lustre/include/linux/obd_class.h b/lustre/include/linux/obd_class.h index f83acf7..c8aa556 100644 --- a/lustre/include/linux/obd_class.h +++ b/lustre/include/linux/obd_class.h @@ -589,6 +589,11 @@ static inline void iattr_from_obdo(struct iattr *attr, struct obdo *oa, /* WARNING: the file systems must take care not to tinker with attributes they don't manage (such as blocks). */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) +#define to_kdev_t(dev) dev +#define to_dev_t(dev) dev +#endif + static inline void obdo_from_inode(struct obdo *dst, struct inode *src, obd_flag valid) { @@ -621,7 +626,7 @@ static inline void obdo_from_inode(struct obdo *dst, struct inode *src, if (valid & OBD_MD_FLGENER) dst->o_generation = src->i_generation; if (valid & OBD_MD_FLRDEV) - dst->o_rdev = src->i_rdev; + dst->o_rdev = to_kdev_t(src->i_rdev); dst->o_valid |= (valid & ~OBD_MD_FLID); } @@ -658,7 +663,7 @@ static inline void obdo_to_inode(struct inode *dst, struct obdo *src, if (valid & OBD_MD_FLGENER) dst->i_generation = src->o_generation; if (valid & OBD_MD_FLRDEV) - dst->i_rdev = src->o_rdev; + dst->i_rdev = to_dev_t(src->o_rdev); } #endif diff --git a/lustre/include/linux/obd_support.h b/lustre/include/linux/obd_support.h index 0f3005c..3c11ffd 100644 --- a/lustre/include/linux/obd_support.h +++ b/lustre/include/linux/obd_support.h @@ -124,20 +124,22 @@ do { \ #define fixme() CDEBUG(D_OTHER, "FIXME\n"); -static inline void OBD_FAIL_WRITE(int id, kdev_t dev) -{ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) -# define __bdevname bdevname +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) +#define ll_bdevname(a) __bdevname((a)) +#else +#define ll_bdevname(a) bdevname((a)) #endif +static inline void OBD_FAIL_WRITE(int id, kdev_t dev) +{ if (OBD_FAIL_CHECK(id)) { #ifdef CONFIG_DEV_RDONLY CERROR("obd_fail_loc=%x, fail write operation on %s\n", - id, __bdevname(dev)); + id, ll_bdevname(dev)); dev_set_rdonly(dev, 2); #else CERROR("obd_fail_loc=%x, can't fail write operation on %s\n", - id, __bdevname(dev)); + id, ll_bdevname(dev)); #endif /* We set FAIL_ONCE because we never "un-fail" a device */ obd_fail_loc |= OBD_FAILED | OBD_FAIL_ONCE; diff --git a/lustre/ldlm/ldlm_test.c b/lustre/ldlm/ldlm_test.c index d28558f..fa387a0 100644 --- a/lustre/ldlm/ldlm_test.c +++ b/lustre/ldlm/ldlm_test.c @@ -438,7 +438,11 @@ static int ldlm_test_main(void *data) daemonize(); spin_lock_irq(¤t->sigmask_lock); sigfillset(¤t->blocked); +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) + recalc_sigpending(); +#else recalc_sigpending(current); +#endif spin_unlock_irq(¤t->sigmask_lock); sprintf(current->comm, "ldlm_test"); diff --git a/lustre/lib/mds_updates.c b/lustre/lib/mds_updates.c index bd7c640..b1393bb 100644 --- a/lustre/lib/mds_updates.c +++ b/lustre/lib/mds_updates.c @@ -18,7 +18,11 @@ #include #include #include -#include +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) +#include // for wait_on_buffer +#else +#include // for wait_on_buffer +#endif #include #include diff --git a/lustre/llite/Makefile.am b/lustre/llite/Makefile.am index 7078657..6ae11c8 100644 --- a/lustre/llite/Makefile.am +++ b/lustre/llite/Makefile.am @@ -9,7 +9,7 @@ MODULE = llite modulefs_DATA = llite.o EXTRA_PROGRAMS = llite -llite_SOURCES = dcache.c commit_callback.c super.c rw.c +llite_SOURCES = dcache.c commit_callback.c super.c rw.c super25.c llite_SOURCES += file.c dir.c sysctl.c namei.c symlink.c llite_SOURCES += lov_pack.c recover.c diff --git a/lustre/llite/commit_callback.c b/lustre/llite/commit_callback.c index ee6ae03..0be55df 100644 --- a/lustre/llite/commit_callback.c +++ b/lustre/llite/commit_callback.c @@ -60,7 +60,7 @@ static int ll_commitcbd_main(void *arg) daemonize(); spin_lock_irq(¤t->sigmask_lock); sigfillset(¤t->blocked); - recalc_sigpending(current); + our_recalc_sigpending(current); spin_unlock_irq(¤t->sigmask_lock); sprintf(current->comm, "lustre_commitcbd"); diff --git a/lustre/llite/dcache.c b/lustre/llite/dcache.c index fe98319..5a6b715 100644 --- a/lustre/llite/dcache.c +++ b/lustre/llite/dcache.c @@ -40,13 +40,12 @@ void ll_release(struct dentry *de) EXIT; } -void ll_intent_release(struct dentry *de) +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) +void ll_intent_release(struct dentry *de, struct lookup_intent *it) { - struct lookup_intent *it; struct lustre_handle *handle; ENTRY; - it = de->d_it; if (it == NULL) { EXIT; return; @@ -65,10 +64,10 @@ void ll_intent_release(struct dentry *de) } else ldlm_lock_decref(handle, it->it_lock_mode); } - de->d_it = NULL; //up(&ll_d2d(de)->lld_it_sem); EXIT; } +#endif int ll_revalidate2(struct dentry *de, int flags, struct lookup_intent *it) { diff --git a/lustre/llite/dir.c b/lustre/llite/dir.c index 20ca043..15dd4c6 100644 --- a/lustre/llite/dir.c +++ b/lustre/llite/dir.c @@ -30,13 +30,13 @@ #include #include #include +#include #include #include -#include #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) -# include // for wait_on_buffer -#else -# include // for wait_on_buffer +#include // for wait_on_buffer +#else +#include // for wait_on_buffer #endif #define DEBUG_SUBSYSTEM S_LLITE diff --git a/lustre/llite/file.c b/lustre/llite/file.c index 23c5edd..b8966d9 100644 --- a/lustre/llite/file.c +++ b/lustre/llite/file.c @@ -673,7 +673,9 @@ loff_t ll_file_seek(struct file *file, loff_t offset, int origin) if (offset >= 0 && offset <= inode->i_sb->s_maxbytes) { if (offset != file->f_pos) { file->f_pos = offset; +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) file->f_reada = 0; +#endif file->f_version = ++event; } retval = offset; diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c index 5ea09b3..627302c6 100644 --- a/lustre/llite/namei.c +++ b/lustre/llite/namei.c @@ -28,9 +28,8 @@ */ #include -#include -#include #include +#include #include #include @@ -164,10 +163,8 @@ static struct dentry *ll_lookup2(struct inode *dir, struct dentry *dentry, RETURN(ERR_PTR(-EIO)); } - if (it == NULL) { + if (it == NULL) it = &lookup_it; - dentry->d_it = it; - } CDEBUG(D_INFO, "name: %*s, intent: %s\n", dentry->d_name.len, dentry->d_name.name, ldlm_it2str(it->it_op)); @@ -281,7 +278,7 @@ static struct dentry *ll_lookup2(struct inode *dir, struct dentry *dentry, if (!inode) { ptlrpc_free_req(request); - ll_intent_release(dentry); + ll_intent_release(dentry, it); RETURN(ERR_PTR(-ENOMEM)); } @@ -292,13 +289,19 @@ static struct dentry *ll_lookup2(struct inode *dir, struct dentry *dentry, dentry->d_op = &ll_d_ops; d_add(dentry, inode); - if (ll_d2d(dentry) == NULL) - ll_set_dd(dentry); - // down(&ll_d2d(dentry)->lld_it_sem); - // dentry->d_it = it; + if (it->it_status == 0) { + LL_SAVE_INTENT(dentry, it); + } + else { + dentry->d_it = NULL; + CDEBUG(D_DENTRY, + "D_IT dentry %p fsdata %p intent: %s status %d\n", + dentry, ll_d2d(dentry), ldlm_it2str(it->it_op), + it->it_status); + } if (it->it_op == IT_LOOKUP) - ll_intent_release(dentry); + ll_intent_release(dentry, it); return NULL; @@ -462,7 +465,7 @@ static int ll_create(struct inode *dir, struct dentry *dentry, int mode) CHECK_MOUNT_EPOCH(dir); - it = dentry->d_it; + LL_GET_INTENT(dentry, it); inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len, NULL, 0, mode, 0, it, NULL); @@ -489,8 +492,8 @@ static int ll_mknod(struct inode *dir, struct dentry *dentry, int mode, struct lookup_intent *it; struct inode *inode; int rc = 0; - - it = dentry->d_it; + + LL_GET_INTENT(dentry, it); inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len, NULL, 0, mode, rdev, it, NULL); @@ -519,7 +522,7 @@ static int ll_symlink(struct inode *dir, struct dentry *dentry, CHECK_MOUNT_EPOCH(dir); - it = dentry->d_it; + LL_GET_INTENT(dentry, it); inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len, symname, l, S_IFLNK | S_IRWXUGO, 0, it, NULL); @@ -553,8 +556,8 @@ static int ll_link(struct dentry *old_dentry, struct inode * dir, struct lookup_intent *it; struct inode *inode = old_dentry->d_inode; int rc; - - it = dentry->d_it; + + LL_GET_INTENT(dentry, it); if (it && it->it_disposition) { if (it->it_status) @@ -592,6 +595,8 @@ static int ll_mkdir(struct inode *dir, struct dentry *dentry, int mode) int err = -EMLINK; ENTRY; + LL_GET_INTENT(dentry, it); + if (dir->i_nlink >= EXT2_LINK_MAX) goto out; @@ -640,7 +645,7 @@ static int ll_common_unlink(struct inode *dir, struct dentry *dentry, struct inode *inode = dentry->d_inode; struct ext2_dir_entry_2 * de; struct page * page; - int rc; + int rc = 0; if (it && it->it_disposition) { rc = it->it_status; @@ -676,9 +681,9 @@ out: static int ll_unlink(struct inode *dir, struct dentry *dentry) { - struct lookup_intent *it; + struct lookup_intent * it; - it = dentry->d_it; + LL_GET_INTENT(dentry, it); return ll_common_unlink(dir, dentry, it, S_IFREG); } @@ -690,7 +695,8 @@ static int ll_rmdir(struct inode *dir, struct dentry *dentry) int rc; ENTRY; - it = dentry->d_it; + LL_GET_INTENT(dentry, it); + if ((!it || !it->it_disposition) && !ext2_empty_dir(inode)) RETURN(-ENOTEMPTY); @@ -717,9 +723,9 @@ static int ll_rename(struct inode * old_dir, struct dentry * old_dentry, struct page * old_page; int err; - it = new_dentry->d_it; + LL_GET_INTENT(new_dentry, it); - if (it && it->it_disposition) { + if (it && it->it_disposition) { if (tgt_inode) { tgt_inode->i_ctime = CURRENT_TIME; tgt_inode->i_nlink--; diff --git a/lustre/llite/rw.c b/lustre/llite/rw.c index 41754c0..be36447 100644 --- a/lustre/llite/rw.c +++ b/lustre/llite/rw.c @@ -33,6 +33,8 @@ #include #include +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) + /* * Remove page from dirty list */ @@ -379,3 +381,4 @@ struct address_space_operations ll_aops = { commit_write: ll_commit_write, bmap: NULL }; +#endif diff --git a/lustre/llite/super.c b/lustre/llite/super.c index d8bf664..dbf93d8 100644 --- a/lustre/llite/super.c +++ b/lustre/llite/super.c @@ -13,6 +13,7 @@ #include #include +#include #include #include #include @@ -20,6 +21,7 @@ #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; @@ -601,3 +603,4 @@ MODULE_LICENSE("GPL"); module_init(init_lustre_lite); module_exit(exit_lustre_lite); +#endif diff --git a/lustre/llite/super25.c b/lustre/llite/super25.c new file mode 100644 index 0000000..10feafe --- /dev/null +++ b/lustre/llite/super25.c @@ -0,0 +1,677 @@ +/* -*- 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) 2002 Cluster File Systems, Inc. + */ + +#define DEBUG_SUBSYSTEM S_LLITE + +#include +#include +#include +#include +#include +#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_init_inodecache(void); +extern void ll_destroy_inodecache(void); +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 *); +static int ll_read_inode2(struct inode *inode, void *opaque); + +static char *ll_read_opt(const char *opt, char *data) +{ + char *value; + char *retval; + 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); + } + + memcpy(retval, value, strlen(value)+1); + CDEBUG(D_SUPER, "Assigned option: %s, value %s\n", opt, retval); + RETURN(retval); +} + +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 *opt_ptr = options; + char *this_char; + ENTRY; + + if (!options) { + EXIT; + return; + } + + while ((this_char = strsep (&opt_ptr, ",")) != NULL) { + 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; +} + +#ifndef log2 +#define log2(n) ffz(~(n)) +#endif + + +static int ll_fill_super(struct super_block *sb, void *data, int silent) +{ + struct inode *root = 0; + struct obd_device *obd; + struct ll_sb_info *sbi; + char *osc = NULL; + char *mdc = NULL; + int err; + struct ll_fid rootfid; + struct obd_statfs osfs; + __u64 last_committed; + __u64 last_xid; + struct ptlrpc_request *request = NULL; + struct ptlrpc_connection *mdc_conn; + struct ll_read_inode2_cookie lic; + class_uuid_t uuid; + + ENTRY; + MOD_INC_USE_COUNT; + + OBD_ALLOC(sbi, sizeof(*sbi)); + if (!sbi) { + MOD_DEC_USE_COUNT; + RETURN(-ENOMEM); + } + + INIT_LIST_HEAD(&sbi->ll_conn_chain); + sbi->ll_mount_epoch = 0; + 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); + } + + /* XXX: need to store the last_* values somewhere */ + err = mdc_getstatus(&sbi->ll_mdc_conn, &rootfid, &last_committed, + &last_xid, &request); + ptlrpc_req_finished(request); + if (err) { + CERROR("cannot mds_connect: rc = %d\n", err); + GOTO(out_mdc, sb = NULL); + } + CDEBUG(D_SUPER, "rootfid %Ld\n", (unsigned long long)rootfid.id); + sbi->ll_rootino = rootfid.id; + + memset(&osfs, 0, sizeof(osfs)); + request = NULL; + err = mdc_statfs(&sbi->ll_mdc_conn, &osfs, &request); + ptlrpc_req_finished(request); + 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 */ + request = NULL; + 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: rc = %d\n", err); + GOTO(out_request, sb = NULL); + } + + /* 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; + root = iget5_locked(sb, sbi->ll_rootino, NULL, + ll_read_inode2, &lic); + + if (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); + +out_dev: + if (mdc) + OBD_FREE(mdc, strlen(mdc) + 1); + if (osc) + OBD_FREE(osc, strlen(osc) + 1); + + RETURN(0); + +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_fill_super */ + +struct super_block * ll_get_sb(struct file_system_type *fs_type, + int flags, char *devname, void * data) +{ + return get_sb_nodev(fs_type, flags, data, ll_fill_super); +} + +static void ll_put_super(struct super_block *sb) +{ + struct ll_sb_info *sbi = ll_s2sbi(sb); + + ENTRY; + list_del(&sbi->ll_conn_chain); + ll_commitcbd_cleanup(sbi); + obd_disconnect(&sbi->ll_osc_conn); + 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) +{ + ENTRY; + + 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; +} + +static void ll_delete_inode(struct 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 */ +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; + } +out: + return error; +} + +int ll_inode_setattr(struct inode *inode, struct iattr *attr, int do_trunc) +{ + struct ptlrpc_request *request = NULL; + struct ll_sb_info *sbi = ll_i2sbi(inode); + int err; + + ENTRY; + + /* change incore inode */ + ll_attr2inode(inode, attr, do_trunc); + + err = mdc_setattr(&sbi->ll_mdc_conn, inode, attr, &request); + if (err) + CERROR("mdc_setattr fails (%d)\n", err); + + ptlrpc_req_finished(request); + + RETURN(err); +} + +int ll_setattr(struct dentry *de, struct iattr *attr) +{ + 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 *sfs) +{ + struct ptlrpc_request *request = NULL; + struct ll_sb_info *sbi = ll_s2sbi(sb); + struct obd_statfs osfs; + int rc; + ENTRY; + + memset(sfs, 0, sizeof(*sfs)); + rc = mdc_statfs(&sbi->ll_mdc_conn, &osfs, &request); + statfs_unpack(sfs, &osfs); + ptlrpc_req_finished(request); + 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; + } + +out: + RETURN(rc); +} + +void ll_update_inode(struct inode *inode, struct mds_body *body) +{ + 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 = to_kdev_t(body->rdev); + if (body->valid & OBD_MD_FLSIZE) + inode->i_size = body->size; +} + +static int ll_read_inode2(struct inode *inode, void *opaque) +{ + 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); + lli->lli_mount_epoch = ll_i2sbi(inode)->ll_mount_epoch; + + /* 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; + + 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); */ + + if (S_ISREG(inode->i_mode)) { + inode->i_op = &ll_file_inode_operations; + inode->i_fop = &ll_file_operations; + inode->i_mapping->a_ops = &ll_aops; + EXIT; + } else if (S_ISDIR(inode->i_mode)) { + inode->i_op = &ll_dir_inode_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; + EXIT; + } else { + init_special_inode(inode, inode->i_mode, + kdev_t_to_nr(inode->i_rdev)); + EXIT; + } + return 0; +} + +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 %d 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); + } +} + +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); + 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; +} + + +static kmem_cache_t *ll_inode_cachep; + +static struct inode *ll_alloc_inode(struct super_block *sb) +{ + struct ll_inode_info *lli; + lli = kmem_cache_alloc(ll_inode_cachep, SLAB_KERNEL); + if (!lli) + return NULL; + + memset(lli, 0, sizeof(*lli)); + sema_init(&lli->lli_open_sem, 1); + lli->lli_mount_epoch = ll_i2sbi(&lli->lli_vfs_inode)->ll_mount_epoch; + + return &lli->lli_vfs_inode; +} + +static void ll_destroy_inode(struct inode *inode) +{ + kmem_cache_free(ll_inode_cachep, LL_I(inode)); +} + +static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags) +{ + struct ll_inode_info *lli = foo; + + if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) == + SLAB_CTOR_CONSTRUCTOR) + inode_init_once(&lli->lli_vfs_inode); +} + +int ll_init_inodecache(void) +{ + ll_inode_cachep = kmem_cache_create("lustre_inode_cache", + sizeof(struct ll_inode_info), + 0, SLAB_HWCACHE_ALIGN, + init_once, NULL); + if (ll_inode_cachep == NULL) + return -ENOMEM; + return 0; +} + +void ll_destroy_inodecache(void) +{ + if (kmem_cache_destroy(ll_inode_cachep)) + CERROR("ll_inode_cache: not all structures were freed\n"); +} + + + +/* exported operations */ +struct super_operations ll_super_operations = +{ + alloc_inode: ll_alloc_inode, + destroy_inode: ll_destroy_inode, + clear_inode: ll_clear_inode, + delete_inode: ll_delete_inode, + put_super: ll_put_super, + statfs: ll_statfs, + umount_begin: ll_umount_begin +}; + +struct file_system_type lustre_lite_fs_type = { + .owner = THIS_MODULE, + .name = "lustre_lite", + .get_sb = ll_get_sb, + .kill_sb = kill_litter_super, +}; + +static int __init init_lustre_lite(void) +{ + int rc; + printk(KERN_INFO "Lustre Lite 0.5.14, info@clusterfs.com\n"); + rc = ll_init_inodecache(); + if (rc) + return -ENOMEM; + 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) { + ll_destroy_inodecache(); + return -ENOMEM; + } + return register_filesystem(&lustre_lite_fs_type); +} + +static void __exit exit_lustre_lite(void) +{ + unregister_filesystem(&lustre_lite_fs_type); + ll_destroy_inodecache(); + kmem_cache_destroy(ll_file_data_slab); +} + +MODULE_AUTHOR("Cluster File Systems, Inc. "); +MODULE_DESCRIPTION("Lustre Lite Client File System v1.0"); +MODULE_LICENSE("GPL"); + +module_init(init_lustre_lite); +module_exit(exit_lustre_lite); +#endif diff --git a/lustre/llite/symlink.c b/lustre/llite/symlink.c index 655574b..d522485 100644 --- a/lustre/llite/symlink.c +++ b/lustre/llite/symlink.c @@ -22,7 +22,7 @@ #include #include #include - +#include #define DEBUG_SUBSYSTEM S_LLITE #include diff --git a/lustre/obdclass/lprocfs.c b/lustre/obdclass/lprocfs.c index 4aa6c94..a683dac 100644 --- a/lustre/obdclass/lprocfs.c +++ b/lustre/obdclass/lprocfs.c @@ -48,6 +48,7 @@ #define DEBUG_SUBSYSTEM S_CLASS #define MAX_STRING_SIZE 100 + #include #include #include diff --git a/lustre/obdfilter/Makefile.am b/lustre/obdfilter/Makefile.am index 34b6c7a..68eeee2 100644 --- a/lustre/obdfilter/Makefile.am +++ b/lustre/obdfilter/Makefile.am @@ -21,8 +21,5 @@ obdfilter_SOURCES = $(FILTERC) $(LINX) dist-hook: list='$(LINX)'; for f in $$list; do rm -f $(distdir)/$$f; done -distclean: - $(RM) Makefile.in - include $(top_srcdir)/Rules diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c index f87a392..127be7c 100644 --- a/lustre/obdfilter/filter.c +++ b/lustre/obdfilter/filter.c @@ -1001,10 +1001,10 @@ static inline void lustre_put_page(struct page *page) page_cache_release(page); } + #ifndef PageUptodate #define PageUptodate(page) Page_Uptodate(page) #endif - static struct page * lustre_get_page_read(struct inode *inode, unsigned long index) { @@ -1076,9 +1076,12 @@ static int lustre_commit_write(struct page *page, unsigned from, unsigned to) int err; err = page->mapping->a_ops->commit_write(NULL, page, from, to); +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) if (!err && IS_SYNC(inode)) err = waitfor_one_page(page); - +#else +#warn ADD 2.5 waiting code here? +#endif //SetPageUptodate(page); // the client commit_write will do this SetPageReferenced(page); diff --git a/lustre/ptlrpc/recovd.c b/lustre/ptlrpc/recovd.c index 336633f..b3a76f4 100644 --- a/lustre/ptlrpc/recovd.c +++ b/lustre/ptlrpc/recovd.c @@ -276,7 +276,12 @@ static int recovd_main(void *arg) daemonize(); spin_lock_irq(¤t->sigmask_lock); sigfillset(¤t->blocked); + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) + recalc_sigpending(); +#else recalc_sigpending(current); +#endif spin_unlock_irq(¤t->sigmask_lock); sprintf(current->comm, "lustre_recovd"); diff --git a/lustre/ptlrpc/service.c b/lustre/ptlrpc/service.c index d12fb89..5bebd0a 100644 --- a/lustre/ptlrpc/service.c +++ b/lustre/ptlrpc/service.c @@ -241,7 +241,11 @@ static int ptlrpc_main(void *arg) daemonize(); spin_lock_irq(¤t->sigmask_lock); sigfillset(¤t->blocked); +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) + recalc_sigpending(); +#else recalc_sigpending(current); +#endif spin_unlock_irq(¤t->sigmask_lock); strcpy(current->comm, data->name); -- 1.8.3.1