X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Finclude%2Flinux%2Flvfs.h;h=4c3c8e125a12bab0c233751c64aad085999e11d3;hb=4ff551e15e6f0aff75520abe6e6e06c0e377a765;hp=3585660212761afd6c29bf902a1ce23c1d1c7249;hpb=c39489126f88bb5b30643ebb11c72fbe9f9d2241;p=fs%2Flustre-release.git diff --git a/lustre/include/linux/lvfs.h b/lustre/include/linux/lvfs.h index 3585660..4c3c8e1 100644 --- a/lustre/include/linux/lvfs.h +++ b/lustre/include/linux/lvfs.h @@ -1,14 +1,41 @@ +/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- + * vim:expandtab:shiftwidth=8:tabstop=8: + * + * Copyright (C) 2001, 2002, 2003, 2004 Cluster File Systems, Inc. + * + * Author: + * + * This file is part of Lustre, http://www.lustre.org. + * + * 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. + * + * 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 + * along with Lustre; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * lustre VFS/process permission interface + */ + #ifndef __LVFS_H__ #define __LVFS_H__ -#include +#include -#define LL_FID_NAMELEN (16 + 1 + 8 + 1) +#define LL_ID_NAMELEN (16 + 1 + 8 + 1) #if defined __KERNEL__ +#include +#include #include #include -#endif +#endif #ifdef LIBLUSTRE #include @@ -18,17 +45,20 @@ struct mds_grp_hash_entry; /* simple.c */ struct lvfs_ucred { - struct mds_grp_hash_entry *luc_ghash; - struct group_info *luc_ginfo; - __u32 luc_fsuid; - __u32 luc_fsgid; - __u32 luc_cap; - __u32 luc_uid; - __u32 luc_umask; + struct lustre_sec_desc *luc_lsd; + struct group_info *luc_ginfo; + __u64 luc_nid; + __u32 luc_uid; + __u32 luc_gid; + __u32 luc_fsuid; + __u32 luc_fsgid; + __u32 luc_cap; + __u32 luc_umask; }; struct lvfs_callback_ops { - struct dentry *(*l_fid2dentry)(__u64 id_ino, __u32 gen, __u64 gr, void *data); + struct dentry *(*l_id2dentry)(__u64 ino, __u32 gen, + __u64 gr, void *data); }; #define OBD_RUN_CTXT_MAGIC 0xC0FFEEAA @@ -51,6 +81,13 @@ struct lvfs_run_ctxt { #endif }; +struct lvfs_obd_ctxt { + struct vfsmount *loc_mnt; + atomic_t loc_refcount; + char *loc_name; + struct list_head loc_list; +}; + #ifdef OBD_CTXT_DEBUG #define OBD_SET_CTXT_MAGIC(ctxt) (ctxt)->magic = OBD_RUN_CTXT_MAGIC #else @@ -58,7 +95,8 @@ struct lvfs_run_ctxt { #endif /* lvfs_common.c */ -struct dentry *lvfs_fid2dentry(struct lvfs_run_ctxt *, __u64, __u32, __u64 ,void *data); +struct dentry *lvfs_id2dentry(struct lvfs_run_ctxt *, __u64, + __u32, __u64 ,void *data); void push_ctxt(struct lvfs_run_ctxt *save, struct lvfs_run_ctxt *new_ctx, struct lvfs_ucred *cred); @@ -74,7 +112,9 @@ 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); long l_readdir(struct file * file, struct list_head *dentry_list); - +int lvfs_mount_fs(char *name, char *fstype, char *options, int flags, + struct lvfs_obd_ctxt **lvfs_ctxt); +void lvfs_umount_fs(struct lvfs_obd_ctxt *lvfs_ctxt); static inline void l_dput(struct dentry *de) { if (!de || IS_ERR(de)) @@ -89,33 +129,56 @@ void *lock_dir(struct inode *dir, struct qstr *name); void unlock_dir(struct inode *dir, void *lock); #endif -/* We need to hold the inode semaphore over the dcache lookup itself, or we - * run the risk of entering the filesystem lookup path concurrently on SMP - * systems, and instantiating two inodes for the same entry. We still - * protect against concurrent addition/removal races with the DLM locking. +/* + * typeof here is to suppress gcc warnings (gcc4, maybe others too) about wrong + * type in assignment. As kernel type may be chnaged we doing it this way. + * --umka */ -static inline struct dentry *ll_lookup_one_len(const char *fid_name, - struct dentry *dparent, - int fid_namelen) +#define qstr_assign(qstr, n, l) \ +do { \ + typeof(l) _len = (l); \ + typeof(n) _name = (n); \ + (qstr)->name = (typeof((qstr)->name))_name; \ + (qstr)->len = (typeof((qstr)->len))_len; \ +} while (0) + +/* We need to hold the inode semaphore over the dcache lookup itself, or we run + * the risk of entering the filesystem lookup path concurrently on SMP systems, + * and instantiating two inodes for the same entry. We still protect against + * concurrent addition/removal races with the DLM locking. */ +static inline struct dentry * +ll_lookup_one_len(const char *name, struct dentry *dparent, int namelen) { struct dentry *dchild; + #ifdef S_PDIROPS - struct qstr qstr; - void *lock; - qstr.name = fid_name; - qstr.len = fid_namelen; - lock = lock_dir(dparent->d_inode, &qstr); + struct qstr qstr; + void *lock; + + qstr_assign(&qstr, name, namelen); + lock = lock_dir(dparent->d_inode, &qstr); #else down(&dparent->d_inode->i_sem); #endif - dchild = lookup_one_len(fid_name, dparent, fid_namelen); + dchild = lookup_one_len(name, dparent, namelen); #ifdef S_PDIROPS - unlock_dir(dparent->d_inode, lock); + unlock_dir(dparent->d_inode, lock); #else up(&dparent->d_inode->i_sem); #endif + + if (IS_ERR(dchild) || dchild->d_inode == NULL) + return dchild; + + if (is_bad_inode(dchild->d_inode)) { + CERROR("bad inode returned %lu/%u\n", + dchild->d_inode->i_ino, dchild->d_inode->i_generation); + dput(dchild); + dchild = ERR_PTR(-ENOENT); + } + return dchild; } @@ -127,9 +190,10 @@ static inline void ll_sleep(int t) } #endif -static inline int ll_fid2str(char *str, __u64 id, __u32 generation) +static inline int ll_id2str(char *str, __u64 id, __u32 generation) { - return sprintf(str, "%llx:%08x", (unsigned long long)id, generation); + return sprintf(str, "%llx:%08x", (unsigned long long)id, + generation); } #endif