lustre/llite/llite_nfs.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *   NFS export of Lustre Light File System
   5  *
   6  *   Copyright (c) 2002, 2003 Cluster File Systems, Inc.
   7  *
   8  *   This file is part of Lustre, http://www.lustre.org.
   9  *
  10  *   Lustre is free software; you can redistribute it and/or
  11  *   modify it under the terms of version 2 of the GNU General Public
  12  *   License as published by the Free Software Foundation.
  13  *
  14  *   Lustre is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU General Public License
  20  *   along with Lustre; if not, write to the Free Software
  21  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #define DEBUG_SUBSYSTEM S_LLITE
  25 #include <lustre_lite.h>
  26 #include "llite_internal.h"
  27
  28 __u32 get_uuid2int(const char *name, int len)
  29 {
  30         __u32 key0 = 0x12a3fe2d, key1 = 0x37abe8f9;
  31         while (len--) {
  32                 __u32 key = key1 + (key0 ^ (*name++ * 7152373));
  33                 if (key & 0x80000000) key -= 0x7fffffff;
  34                 key1 = key0;
  35                 key0 = key;
  36         }
  37         return (key0 << 1);
  38 }
  39
  40 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
  41 static int ll_nfs_test_inode(struct inode *inode, unsigned long ino, void *opaque)
  42 #else
  43 static int ll_nfs_test_inode(struct inode *inode, void *opaque)
  44 #endif
  45 {
  46         struct ll_fid *iid = opaque;
  47
  48         if (inode->i_ino == iid->id && inode->i_generation == iid->generation)
  49                 return 1;
  50
  51         return 0;
  52 }
  53
  54 static struct inode * search_inode_for_lustre(struct super_block *sb,
  55                                               unsigned long ino,
  56                                               unsigned long generation,
  57                                               int mode)
  58 {
  59         struct ptlrpc_request *req = NULL;
  60         struct ll_sb_info *sbi = ll_s2sbi(sb);
  61         struct ll_fid fid;
  62         unsigned long valid = 0;
  63         int eadatalen = 0, rc;
  64         struct inode *inode = NULL;
  65         struct ll_fid iid = { .id = ino, .generation = generation };
  66         ENTRY;
  67
  68         inode = ILOOKUP(sb, ino, ll_nfs_test_inode, &iid);
  69
  70         if (inode)
  71                 RETURN(inode);
  72         if (S_ISREG(mode)) {
  73                 rc = ll_get_max_mdsize(sbi, &eadatalen);
  74                 if (rc)
  75                         RETURN(ERR_PTR(rc));
  76                 valid |= OBD_MD_FLEASIZE;
  77         }
  78         fid.id = (__u64)ino;
  79         fid.generation = generation;
  80         fid.f_type = mode;
  81
  82         rc = mdc_getattr(sbi->ll_mdc_exp, &fid, valid, eadatalen, &req);
  83         if (rc) {
  84                 CERROR("failure %d inode %lu\n", rc, ino);
  85                 RETURN(ERR_PTR(rc));
  86         }
  87
  88         rc = ll_prep_inode(sbi->ll_osc_exp, &inode, req, REPLY_REC_OFF, sb);
  89         if (rc) {
  90                 ptlrpc_req_finished(req);
  91                 RETURN(ERR_PTR(rc));
  92         }
  93         ptlrpc_req_finished(req);
  94
  95         RETURN(inode);
  96 }
  97
  98 extern struct dentry_operations ll_d_ops;
  99
 100 static struct dentry *ll_iget_for_nfs(struct super_block *sb, unsigned long ino,
 101                                       __u32 generation, umode_t mode)
 102 {
 103         struct inode *inode;
 104         struct dentry *result;
 105 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 106         struct list_head *lp;
 107 #endif
 108         ENTRY;
 109
 110         if (ino == 0)
 111                 RETURN(ERR_PTR(-ESTALE));
 112
 113         inode = search_inode_for_lustre(sb, ino, generation, mode);
 114         if (IS_ERR(inode)) {
 115                 RETURN(ERR_PTR(PTR_ERR(inode)));
 116         }
 117         if (is_bad_inode(inode) ||
 118             (generation && inode->i_generation != generation)){
 119                 /* we didn't find the right inode.. */
 120                 CERROR("Inode %lu, Bad count: %lu %d or version  %u %u\n",
 121                        inode->i_ino, (unsigned long)inode->i_nlink,
 122                        atomic_read(&inode->i_count), inode->i_generation,
 123                        generation);
 124                 iput(inode);
 125                 RETURN(ERR_PTR(-ESTALE));
 126         }
 127
 128 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 129         result = d_alloc_anon(inode);
 130         if (!result) {
 131                 iput(inode);
 132                 RETURN(ERR_PTR(-ENOMEM));
 133         }
 134 #else
 135         /* now to find a dentry.
 136          * If possible, get a well-connected one
 137          */
 138         spin_lock(&dcache_lock);
 139         for (lp = inode->i_dentry.next; lp != &inode->i_dentry ; lp=lp->next) {
 140                 result = list_entry(lp,struct dentry, d_alias);
 141                 lock_dentry(result);
 142                 if (!(result->d_flags & DCACHE_DISCONNECTED)) {
 143                         dget_locked(result);
 144                         ll_set_dflags(result, DCACHE_REFERENCED);
 145                         unlock_dentry(result);
 146                         spin_unlock(&dcache_lock);
 147                         iput(inode);
 148                         RETURN(result);
 149                 }
 150                 unlock_dentry(result);
 151         }
 152         spin_unlock(&dcache_lock);
 153         result = d_alloc_root(inode);
 154         if (result == NULL) {
 155                 iput(inode);
 156                 RETURN(ERR_PTR(-ENOMEM));
 157         }
 158         result->d_flags |= DCACHE_DISCONNECTED;
 159
 160 #endif
 161         ll_set_dd(result);
 162         result->d_op = &ll_d_ops;
 163         RETURN(result);
 164 }
 165
 166 struct dentry *ll_fh_to_dentry(struct super_block *sb, __u32 *data, int len,
 167                                int fhtype, int parent)
 168 {
 169         switch (fhtype) {
 170                 case 2:
 171                         if (len < 5)
 172                                 break;
 173                         if (parent)
 174                                 return ll_iget_for_nfs(sb, data[3], 0, data[4]);
 175                 case 1:
 176                         if (len < 3)
 177                                 break;
 178                         if (parent)
 179                                 break;
 180                         return ll_iget_for_nfs(sb, data[0], data[1], data[2]);
 181                 default: break;
 182         }
 183         return ERR_PTR(-EINVAL);
 184 }
 185
 186 int ll_dentry_to_fh(struct dentry *dentry, __u32 *datap, int *lenp,
 187                     int need_parent)
 188 {
 189         if (*lenp < 3)
 190                 return 255;
 191         *datap++ = dentry->d_inode->i_ino;
 192         *datap++ = dentry->d_inode->i_generation;
 193         *datap++ = (__u32)(S_IFMT & dentry->d_inode->i_mode);
 194
 195         if (*lenp == 3 || S_ISDIR(dentry->d_inode->i_mode)) {
 196                 *lenp = 3;
 197                 return 1;
 198         }
 199         if (dentry->d_parent) {
 200                 *datap++ = dentry->d_parent->d_inode->i_ino;
 201                 *datap++ = (__u32)(S_IFMT & dentry->d_parent->d_inode->i_mode);
 202
 203                 *lenp = 5;
 204                 return 2;
 205         }
 206         *lenp = 3;
 207         return 1;
 208 }
 209
 210 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 211 struct dentry *ll_get_dentry(struct super_block *sb, void *data)
 212 {
 213         __u32 *inump = (__u32*)data;
 214         return ll_iget_for_nfs(sb, inump[0], inump[1], S_IFREG);
 215 }
 216
 217 struct dentry *ll_get_parent(struct dentry *dchild)
 218 {
 219         struct ptlrpc_request *req = NULL;
 220         struct inode *dir = dchild->d_inode;
 221         struct ll_sb_info *sbi;
 222         struct dentry *result = NULL;
 223         struct ll_fid fid;
 224         struct mds_body *body;
 225         char dotdot[] = "..";
 226         int  rc = 0;
 227         ENTRY;
 228
 229         LASSERT(dir && S_ISDIR(dir->i_mode));
 230
 231         sbi = ll_s2sbi(dir->i_sb);
 232
 233         fid.id = (__u64)dir->i_ino;
 234         fid.generation = dir->i_generation;
 235         fid.f_type = S_IFDIR;
 236
 237         rc = mdc_getattr_name(sbi->ll_mdc_exp, &fid, dotdot, strlen(dotdot) + 1,
 238                               0, 0, &req);
 239         if (rc) {
 240                 CERROR("failure %d inode %lu get parent\n", rc, dir->i_ino);
 241                 return ERR_PTR(rc);
 242         }
 243         body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof (*body));
 244
 245         LASSERT((body->valid & OBD_MD_FLGENER) && (body->valid & OBD_MD_FLID));
 246
 247         result = ll_iget_for_nfs(dir->i_sb, body->ino, body->generation, S_IFDIR);
 248
 249         if (IS_ERR(result))
 250                 rc = PTR_ERR(result);
 251
 252         ptlrpc_req_finished(req);
 253         if (rc)
 254                 return ERR_PTR(rc);
 255         RETURN(result);
 256 }
 257
 258 struct export_operations lustre_export_operations = {
 259        .get_parent = ll_get_parent,
 260        .get_dentry = ll_get_dentry,
 261 };
 262 #endif