X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Flvfs%2Flvfs_linux.c;h=63d29926846d7f3893a9bce34f00d99c1dbee54b;hb=c65b502fe9feda61c7ad7137f5022c654c6ba501;hp=827e7477c43f82958af71e6322d676cfa11775c6;hpb=e903932500fc08b143467ce5a1c2702df35d8f0f;p=fs%2Flustre-release.git diff --git a/lustre/lvfs/lvfs_linux.c b/lustre/lvfs/lvfs_linux.c index 827e747..63d2992 100644 --- a/lustre/lvfs/lvfs_linux.c +++ b/lustre/lvfs/lvfs_linux.c @@ -1,26 +1,43 @@ /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- * vim:expandtab:shiftwidth=8:tabstop=8: * - * lustre/lib/lvfs_linux.c - * Lustre filesystem abstraction routines + * GPL HEADER START * - * Copyright (C) 2002, 2003 Cluster File Systems, Inc. - * Author: Andreas Dilger + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * This file is part of Lustre, http://www.lustre.org. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * Lustre is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * version 2 along with this program; If not, see + * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + * GPL HEADER END + */ +/* + * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. + * Use is subject to license terms. + * + * Copyright (c) 2011, 2012, Whamcloud, Inc. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. + * + * lustre/lvfs/lvfs_linux.c + * + * Author: Andreas Dilger */ #ifndef EXPORT_SYMTAB @@ -52,7 +69,7 @@ __u64 obd_max_pages = 0; __u64 obd_max_alloc = 0; struct lprocfs_stats *obd_memory = NULL; -spinlock_t obd_updatemax_lock = SPIN_LOCK_UNLOCKED; +cfs_spinlock_t obd_updatemax_lock = CFS_SPIN_LOCK_UNLOCKED; /* refine later and change to seqlock or simlar from libcfs */ /* Debugging check only needed during development */ @@ -74,9 +91,13 @@ static void push_group_info(struct lvfs_run_ctxt *save, save->ngroups = current_ngroups; current_ngroups = 0; } else { + struct cred *cred; task_lock(current); - save->group_info = current->group_info; - current->group_info = ginfo; + save->group_info = current_cred()->group_info; + if ((cred = prepare_creds())) { + cred->group_info = ginfo; + commit_creds(cred); + } task_unlock(current); } } @@ -87,8 +108,12 @@ static void pop_group_info(struct lvfs_run_ctxt *save, if (!ginfo) { current_ngroups = save->ngroups; } else { + struct cred *cred; task_lock(current); - current->group_info = save->group_info; + if ((cred = prepare_creds())) { + cred->group_info = save->group_info; + commit_creds(cred); + } task_unlock(current); } } @@ -101,24 +126,13 @@ void push_ctxt(struct lvfs_run_ctxt *save, struct lvfs_run_ctxt *new_ctx, ASSERT_CTXT_MAGIC(new_ctx->magic); OBD_SET_CTXT_MAGIC(save); - /* - CDEBUG(D_INFO, - "= push %p->%p = cur fs %p pwd %p:d%d:i%d (%.*s), pwdmnt %p:%d\n", - save, current, current->fs, current->fs->pwd, - atomic_read(¤t->fs->pwd->d_count), - atomic_read(¤t->fs->pwd->d_inode->i_count), - current->fs->pwd->d_name.len, current->fs->pwd->d_name.name, - current->fs->pwdmnt, - atomic_read(¤t->fs->pwdmnt->mnt_count)); - */ - save->fs = get_fs(); - LASSERT(atomic_read(¤t->fs->pwd->d_count)); - LASSERT(atomic_read(&new_ctx->pwd->d_count)); - save->pwd = dget(current->fs->pwd); - save->pwdmnt = mntget(current->fs->pwdmnt); - save->luc.luc_umask = current->fs->umask; - save->ngroups = current->group_info->ngroups; + LASSERT(cfs_atomic_read(&cfs_fs_pwd(current->fs)->d_count)); + LASSERT(cfs_atomic_read(&new_ctx->pwd->d_count)); + save->pwd = dget(cfs_fs_pwd(current->fs)); + save->pwdmnt = mntget(cfs_fs_mnt(current->fs)); + save->luc.luc_umask = cfs_curproc_umask(); + save->ngroups = current_cred()->group_info->ngroups; LASSERT(save->pwd); LASSERT(save->pwdmnt); @@ -126,17 +140,21 @@ void push_ctxt(struct lvfs_run_ctxt *save, struct lvfs_run_ctxt *new_ctx, LASSERT(new_ctx->pwdmnt); if (uc) { - save->luc.luc_uid = current->uid; - save->luc.luc_gid = current->gid; - save->luc.luc_fsuid = current->fsuid; - save->luc.luc_fsgid = current->fsgid; - save->luc.luc_cap = current->cap_effective; - - current->uid = uc->luc_uid; - current->gid = uc->luc_gid; - current->fsuid = uc->luc_fsuid; - current->fsgid = uc->luc_fsgid; - current->cap_effective = uc->luc_cap; + struct cred *cred; + save->luc.luc_uid = current_uid(); + save->luc.luc_gid = current_gid(); + save->luc.luc_fsuid = current_fsuid(); + save->luc.luc_fsgid = current_fsgid(); + save->luc.luc_cap = current_cap(); + + if ((cred = prepare_creds())) { + cred->uid = uc->luc_uid; + cred->gid = uc->luc_gid; + cred->fsuid = uc->luc_fsuid; + cred->fsgid = uc->luc_fsgid; + cred->cap_effective = uc->luc_cap; + commit_creds(cred); + } push_group_info(save, uc->luc_ginfo ?: @@ -146,43 +164,19 @@ void push_ctxt(struct lvfs_run_ctxt *save, struct lvfs_run_ctxt *new_ctx, current->fs->umask = 0; /* umask already applied on client */ set_fs(new_ctx->fs); ll_set_fs_pwd(current->fs, new_ctx->pwdmnt, new_ctx->pwd); - - /* - CDEBUG(D_INFO, - "= push %p->%p = cur fs %p pwd %p:d%d:i%d (%.*s), pwdmnt %p:%d\n", - new_ctx, current, current->fs, current->fs->pwd, - atomic_read(¤t->fs->pwd->d_count), - atomic_read(¤t->fs->pwd->d_inode->i_count), - current->fs->pwd->d_name.len, current->fs->pwd->d_name.name, - current->fs->pwdmnt, - atomic_read(¤t->fs->pwdmnt->mnt_count)); - */ } EXPORT_SYMBOL(push_ctxt); void pop_ctxt(struct lvfs_run_ctxt *saved, struct lvfs_run_ctxt *new_ctx, struct lvfs_ucred *uc) { - //printk("pc0"); ASSERT_CTXT_MAGIC(saved->magic); - //printk("pc1"); ASSERT_KERNEL_CTXT("popping non-kernel context!\n"); - /* - CDEBUG(D_INFO, - " = pop %p==%p = cur %p pwd %p:d%d:i%d (%.*s), pwdmnt %p:%d\n", - new_ctx, current, current->fs, current->fs->pwd, - atomic_read(¤t->fs->pwd->d_count), - atomic_read(¤t->fs->pwd->d_inode->i_count), - current->fs->pwd->d_name.len, current->fs->pwd->d_name.name, - current->fs->pwdmnt, - atomic_read(¤t->fs->pwdmnt->mnt_count)); - */ - - LASSERTF(current->fs->pwd == new_ctx->pwd, "%p != %p\n", - current->fs->pwd, new_ctx->pwd); - LASSERTF(current->fs->pwdmnt == new_ctx->pwdmnt, "%p != %p\n", - current->fs->pwdmnt, new_ctx->pwdmnt); + LASSERTF(cfs_fs_pwd(current->fs) == new_ctx->pwd, "%p != %p\n", + cfs_fs_pwd(current->fs), new_ctx->pwd); + LASSERTF(cfs_fs_mnt(current->fs) == new_ctx->pwdmnt, "%p != %p\n", + cfs_fs_mnt(current->fs), new_ctx->pwdmnt); set_fs(saved->fs); ll_set_fs_pwd(current->fs, saved->pwdmnt, saved->pwd); @@ -191,27 +185,21 @@ void pop_ctxt(struct lvfs_run_ctxt *saved, struct lvfs_run_ctxt *new_ctx, mntput(saved->pwdmnt); current->fs->umask = saved->luc.luc_umask; if (uc) { - current->uid = saved->luc.luc_uid; - current->gid = saved->luc.luc_gid; - current->fsuid = saved->luc.luc_fsuid; - current->fsgid = saved->luc.luc_fsgid; - current->cap_effective = saved->luc.luc_cap; + struct cred *cred; + if ((cred = prepare_creds())) { + cred->uid = saved->luc.luc_uid; + cred->gid = saved->luc.luc_gid; + cred->fsuid = saved->luc.luc_fsuid; + cred->fsgid = saved->luc.luc_fsgid; + cred->cap_effective = saved->luc.luc_cap; + commit_creds(cred); + } + pop_group_info(saved, uc->luc_ginfo ?: uc->luc_identity ? uc->luc_identity->mi_ginfo : NULL); } - - /* - CDEBUG(D_INFO, - "= pop %p->%p = cur fs %p pwd %p:d%d:i%d (%.*s), pwdmnt %p:%d\n", - saved, current, current->fs, current->fs->pwd, - atomic_read(¤t->fs->pwd->d_count), - atomic_read(¤t->fs->pwd->d_inode->i_count), - current->fs->pwd->d_name.len, current->fs->pwd->d_name.name, - current->fs->pwdmnt, - atomic_read(¤t->fs->pwdmnt->mnt_count)); - */ } EXPORT_SYMBOL(pop_ctxt); @@ -261,7 +249,8 @@ out_up: EXPORT_SYMBOL(simple_mknod); /* utility to make a directory */ -struct dentry *simple_mkdir(struct dentry *dir, char *name, int mode, int fix) +struct dentry *simple_mkdir(struct dentry *dir, struct vfsmount *mnt, + const char *name, int mode, int fix) { struct dentry *dchild; int err = 0; @@ -284,7 +273,7 @@ struct dentry *simple_mkdir(struct dentry *dir, char *name, int mode, int fix) /* Fixup directory permissions if necessary */ if (fix && (old_mode & S_IALLUGO) != (mode & S_IALLUGO)) { - CDEBUG(D_CONFIG, + CDEBUG(D_CONFIG, "fixing permissions on %s from %o to %o\n", name, old_mode, mode); dchild->d_inode->i_mode = (mode & S_IALLUGO) | @@ -294,7 +283,7 @@ struct dentry *simple_mkdir(struct dentry *dir, char *name, int mode, int fix) GOTO(out_up, dchild); } - err = vfs_mkdir(dir->d_inode, dchild, mode); + err = ll_vfs_mkdir(dir->d_inode, dchild, mnt, mode); if (err) GOTO(out_err, err); @@ -309,28 +298,30 @@ out_up: EXPORT_SYMBOL(simple_mkdir); /* utility to rename a file */ -int lustre_rename(struct dentry *dir, char *oldname, char *newname) +int lustre_rename(struct dentry *dir, struct vfsmount *mnt, + char *oldname, char *newname) { struct dentry *dchild_old, *dchild_new; int err = 0; ENTRY; ASSERT_KERNEL_CTXT("kernel doing rename outside kernel context\n"); - CDEBUG(D_INODE, "renaming file %.*s to %.*s\n", + CDEBUG(D_INODE, "renaming file %.*s to %.*s\n", (int)strlen(oldname), oldname, (int)strlen(newname), newname); dchild_old = ll_lookup_one_len(oldname, dir, strlen(oldname)); if (IS_ERR(dchild_old)) RETURN(PTR_ERR(dchild_old)); - if (!dchild_old->d_inode) + if (!dchild_old->d_inode) GOTO(put_old, err = -ENOENT); dchild_new = ll_lookup_one_len(newname, dir, strlen(newname)); if (IS_ERR(dchild_new)) GOTO(put_old, err = PTR_ERR(dchild_new)); - err = vfs_rename(dir->d_inode, dchild_old, dir->d_inode, dchild_new); + err = ll_vfs_rename(dir->d_inode, dchild_old, mnt, + dir->d_inode, dchild_new, mnt); dput(dchild_new); put_old: @@ -386,25 +377,21 @@ int lustre_fsync(struct file *file) if (!file || !file->f_op || !file->f_op->fsync) RETURN(-ENOSYS); - RETURN(file->f_op->fsync(file, file->f_dentry, 0)); + RETURN(cfs_do_fsync(file, 0)); } EXPORT_SYMBOL(lustre_fsync); +/* Note: dput(dchild) will be called if there is an error */ struct l_file *l_dentry_open(struct lvfs_run_ctxt *ctxt, struct l_dentry *de, int flags) { mntget(ctxt->pwdmnt); - return dentry_open(de, ctxt->pwdmnt, flags); + return ll_dentry_open(de, ctxt->pwdmnt, flags, current_cred()); } EXPORT_SYMBOL(l_dentry_open); -#ifdef HAVE_VFS_READDIR_U64_INO static int l_filldir(void *__buf, const char *name, int namlen, loff_t offset, u64 ino, unsigned int d_type) -#else -static int l_filldir(void *__buf, const char *name, int namlen, loff_t offset, - ino_t ino, unsigned int d_type) -#endif { struct l_linux_dirent *dirent; struct l_readdir_callback *buf = (struct l_readdir_callback *)__buf; @@ -418,7 +405,7 @@ static int l_filldir(void *__buf, const char *name, int namlen, loff_t offset, if (!dirent) return -ENOMEM; - list_add_tail(&dirent->lld_list, buf->lrc_list); + cfs_list_add_tail(&dirent->lld_list, buf->lrc_list); buf->lrc_dirent = dirent; dirent->lld_ino = ino; @@ -428,7 +415,7 @@ static int l_filldir(void *__buf, const char *name, int namlen, loff_t offset, return 0; } -long l_readdir(struct file *file, struct list_head *dentry_list) +long l_readdir(struct file *file, cfs_list_t *dentry_list) { struct l_linux_dirent *lastdirent; struct l_readdir_callback buf; @@ -449,199 +436,62 @@ long l_readdir(struct file *file, struct list_head *dentry_list) } EXPORT_SYMBOL(l_readdir); -#if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__) -static spinlock_t obd_memlist_lock = SPIN_LOCK_UNLOCKED; -static struct hlist_head *obd_memtable = NULL; -static unsigned long obd_memtable_size = 0; - -static int lvfs_memdbg_init(int size) -{ - struct hlist_head *head; - int i; - - LASSERT(size > sizeof(sizeof(struct hlist_head))); - obd_memtable_size = size / sizeof(struct hlist_head); - - CWARN("Allocating %lu memdbg entries.\n", - (unsigned long)obd_memtable_size); - - LASSERT(obd_memtable == NULL); - obd_memtable = kmalloc(size, GFP_KERNEL); - if (!obd_memtable) - return -ENOMEM; - - i = obd_memtable_size; - head = obd_memtable; - do { - INIT_HLIST_HEAD(head); - head++; - i--; - } while(i); - - return 0; -} - -static int lvfs_memdbg_cleanup(void) -{ - struct hlist_node *node = NULL, *tmp = NULL; - struct hlist_head *head; - struct obd_mem_track *mt; - int i; - - spin_lock(&obd_memlist_lock); - for (i = 0, head = obd_memtable; i < obd_memtable_size; i++, head++) { - hlist_for_each_safe(node, tmp, head) { - mt = hlist_entry(node, struct obd_mem_track, mt_hash); - hlist_del_init(&mt->mt_hash); - kfree(mt); - } - } - spin_unlock(&obd_memlist_lock); - kfree(obd_memtable); - return 0; -} - -static inline unsigned long const hashfn(void *ptr) -{ - return (unsigned long)ptr & - (obd_memtable_size - 1); -} - -static void __lvfs_memdbg_insert(struct obd_mem_track *mt) -{ - struct hlist_head *head = obd_memtable + - hashfn(mt->mt_ptr); - hlist_add_head(&mt->mt_hash, head); -} - -void lvfs_memdbg_insert(struct obd_mem_track *mt) -{ - spin_lock(&obd_memlist_lock); - __lvfs_memdbg_insert(mt); - spin_unlock(&obd_memlist_lock); -} -EXPORT_SYMBOL(lvfs_memdbg_insert); - -static void __lvfs_memdbg_remove(struct obd_mem_track *mt) -{ - hlist_del_init(&mt->mt_hash); -} - -void lvfs_memdbg_remove(struct obd_mem_track *mt) -{ - spin_lock(&obd_memlist_lock); - __lvfs_memdbg_remove(mt); - spin_unlock(&obd_memlist_lock); -} -EXPORT_SYMBOL(lvfs_memdbg_remove); - -static struct obd_mem_track *__lvfs_memdbg_find(void *ptr) -{ - struct hlist_node *node = NULL; - struct obd_mem_track *mt = NULL; - struct hlist_head *head; - - head = obd_memtable + hashfn(ptr); - - hlist_for_each(node, head) { - mt = hlist_entry(node, struct obd_mem_track, mt_hash); - if ((unsigned long)mt->mt_ptr == (unsigned long)ptr) - break; - mt = NULL; - } - return mt; -} - -struct obd_mem_track *lvfs_memdbg_find(void *ptr) +int l_notify_change(struct vfsmount *mnt, struct dentry *dchild, + struct iattr *newattrs) { - struct obd_mem_track *mt; - - spin_lock(&obd_memlist_lock); - mt = __lvfs_memdbg_find(ptr); - spin_unlock(&obd_memlist_lock); - - return mt; -} -EXPORT_SYMBOL(lvfs_memdbg_find); + int rc; -int lvfs_memdbg_check_insert(struct obd_mem_track *mt) -{ - struct obd_mem_track *tmp; - - spin_lock(&obd_memlist_lock); - tmp = __lvfs_memdbg_find(mt->mt_ptr); - if (tmp == NULL) { - __lvfs_memdbg_insert(mt); - spin_unlock(&obd_memlist_lock); - return 1; - } - spin_unlock(&obd_memlist_lock); - return 0; + LOCK_INODE_MUTEX(dchild->d_inode); +#ifdef HAVE_SECURITY_PLUG + rc = notify_change(dchild, mnt, newattrs); +#else + rc = notify_change(dchild, newattrs); +#endif + UNLOCK_INODE_MUTEX(dchild->d_inode); + return rc; } -EXPORT_SYMBOL(lvfs_memdbg_check_insert); +EXPORT_SYMBOL(l_notify_change); -struct obd_mem_track * -lvfs_memdbg_check_remove(void *ptr) +/* utility to truncate a file */ +int simple_truncate(struct dentry *dir, struct vfsmount *mnt, + char *name, loff_t length) { - struct obd_mem_track *mt; - - spin_lock(&obd_memlist_lock); - mt = __lvfs_memdbg_find(ptr); - if (mt) { - __lvfs_memdbg_remove(mt); - spin_unlock(&obd_memlist_lock); - return mt; - } - spin_unlock(&obd_memlist_lock); - return NULL; -} -EXPORT_SYMBOL(lvfs_memdbg_check_remove); -#endif + struct dentry *dchild; + struct iattr newattrs; + int err = 0; + ENTRY; -void lvfs_memdbg_show(void) -{ -#if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__) - struct hlist_node *node = NULL; - struct hlist_head *head; - struct obd_mem_track *mt; - int header = 0; -#endif - -#if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__) - int i; -#endif + CDEBUG(D_INODE, "truncating file %.*s to %lld\n", (int)strlen(name), + name, (long long)length); + dchild = ll_lookup_one_len(name, dir, strlen(name)); + if (IS_ERR(dchild)) + GOTO(out, err = PTR_ERR(dchild)); - -#if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__) - spin_lock(&obd_memlist_lock); - for (i = 0, head = obd_memtable; i < obd_memtable_size; i++, head++) { - hlist_for_each(node, head) { - if (header == 0) { - CWARN("Abnormal memory activities:\n"); - header = 1; - } - mt = hlist_entry(node, struct obd_mem_track, mt_hash); - CWARN(" [%s] ptr: 0x%p, size: %d, src at %s\n", - ((mt->mt_flags & OBD_MT_WRONG_SIZE) ? - "wrong size" : "leaked memory"), - mt->mt_ptr, mt->mt_size, mt->mt_loc); + if (dchild->d_inode) { + int old_mode = dchild->d_inode->i_mode; + if (S_ISDIR(old_mode)) { + CERROR("found %s (%lu/%u) is mode %o\n", name, + dchild->d_inode->i_ino, + dchild->d_inode->i_generation, old_mode); + GOTO(out_dput, err = -EISDIR); } + + newattrs.ia_size = length; + newattrs.ia_valid = ATTR_SIZE; + err = l_notify_change(mnt, dchild, &newattrs); } - spin_unlock(&obd_memlist_lock); -#endif + EXIT; +out_dput: + dput(dchild); +out: + return err; } -EXPORT_SYMBOL(lvfs_memdbg_show); +EXPORT_SYMBOL(simple_truncate); #ifdef LUSTRE_KERNEL_VERSION -#ifndef HAVE_CLEAR_RDONLY_ON_PUT -#error rdonly patchset must be updated [cfs bz11248] -#endif -void dev_set_rdonly(lvfs_sbdev_type dev); -int dev_check_rdonly(lvfs_sbdev_type dev); - -void __lvfs_set_rdonly(lvfs_sbdev_type dev, lvfs_sbdev_type jdev) +int __lvfs_set_rdonly(lvfs_sbdev_type dev, lvfs_sbdev_type jdev) { - lvfs_sbdev_sync(dev); +#ifdef HAVE_DEV_SET_RDONLY if (jdev && (jdev != dev)) { CDEBUG(D_IOCTL | D_HA, "set journal dev %lx rdonly\n", (long)jdev); @@ -649,14 +499,24 @@ void __lvfs_set_rdonly(lvfs_sbdev_type dev, lvfs_sbdev_type jdev) } CDEBUG(D_IOCTL | D_HA, "set dev %lx rdonly\n", (long)dev); dev_set_rdonly(dev); + + return 0; +#else + CERROR("DEV %lx CANNOT BE SET READONLY\n", (long)dev); + + return -EOPNOTSUPP; +#endif } +EXPORT_SYMBOL(__lvfs_set_rdonly); int lvfs_check_rdonly(lvfs_sbdev_type dev) { +#ifdef HAVE_DEV_SET_RDONLY return dev_check_rdonly(dev); +#else + return 0; +#endif } - -EXPORT_SYMBOL(__lvfs_set_rdonly); EXPORT_SYMBOL(lvfs_check_rdonly); int lvfs_check_io_health(struct obd_device *obd, struct file *file) @@ -687,22 +547,22 @@ void obd_update_maxusage() max1 = obd_pages_sum(); max2 = obd_memory_sum(); - spin_lock(&obd_updatemax_lock); + cfs_spin_lock(&obd_updatemax_lock); if (max1 > obd_max_pages) obd_max_pages = max1; if (max2 > obd_max_alloc) obd_max_alloc = max2; - spin_unlock(&obd_updatemax_lock); - + cfs_spin_unlock(&obd_updatemax_lock); + } __u64 obd_memory_max(void) { __u64 ret; - spin_lock(&obd_updatemax_lock); + cfs_spin_lock(&obd_updatemax_lock); ret = obd_max_alloc; - spin_unlock(&obd_updatemax_lock); + cfs_spin_unlock(&obd_updatemax_lock); return ret; } @@ -711,9 +571,9 @@ __u64 obd_pages_max(void) { __u64 ret; - spin_lock(&obd_updatemax_lock); + cfs_spin_lock(&obd_updatemax_lock); ret = obd_max_pages; - spin_unlock(&obd_updatemax_lock); + cfs_spin_unlock(&obd_updatemax_lock); return ret; } @@ -733,14 +593,14 @@ __s64 lprocfs_read_helper(struct lprocfs_counter *lc, if (!lc) RETURN(0); do { - centry = atomic_read(&lc->lc_cntl.la_entry); + centry = cfs_atomic_read(&lc->lc_cntl.la_entry); switch (field) { case LPROCFS_FIELDS_FLAGS_CONFIG: ret = lc->lc_config; break; case LPROCFS_FIELDS_FLAGS_SUM: - ret = lc->lc_sum; + ret = lc->lc_sum + lc->lc_sum_irq; break; case LPROCFS_FIELDS_FLAGS_MIN: ret = lc->lc_min; @@ -760,38 +620,14 @@ __s64 lprocfs_read_helper(struct lprocfs_counter *lc, default: break; }; - } while (centry != atomic_read(&lc->lc_cntl.la_entry) && - centry != atomic_read(&lc->lc_cntl.la_exit)); + } while (centry != cfs_atomic_read(&lc->lc_cntl.la_entry) && + centry != cfs_atomic_read(&lc->lc_cntl.la_exit)); RETURN(ret); } EXPORT_SYMBOL(lprocfs_read_helper); #endif /* LPROCFS */ -static int __init lvfs_linux_init(void) -{ - ENTRY; -#if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__) - lvfs_memdbg_init(CFS_PAGE_SIZE); -#endif - RETURN(0); -} - -static void __exit lvfs_linux_exit(void) -{ - ENTRY; - - lvfs_memdbg_show(); - -#if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__) - lvfs_memdbg_cleanup(); -#endif - EXIT; -} - -MODULE_AUTHOR("Cluster File Systems, Inc. "); +MODULE_AUTHOR("Sun Microsystems, Inc. "); MODULE_DESCRIPTION("Lustre VFS Filesystem Helper v0.1"); MODULE_LICENSE("GPL"); - -module_init(lvfs_linux_init); -module_exit(lvfs_linux_exit);