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 <linux/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,
  42                              void *opaque)
  43 #else
  44 static int ll_nfs_test_inode(struct inode *inode, void *opaque)
  45 #endif
  46 {
  47         struct lustre_id *iid = opaque;
  48
  49         if (inode->i_ino == id_ino(iid) &&
  50             inode->i_generation == id_gen(iid))
  51                 return 1;
  52
  53         return 0;
  54 }
  55 static struct inode * search_inode_for_lustre(struct super_block *sb,
  56                                               unsigned long ino,
  57                                               unsigned long generation,
  58                                               int mode)
  59 {
  60         struct ptlrpc_request *req = NULL;
  61         struct ll_sb_info *sbi = ll_s2sbi(sb);
  62         struct lustre_id id;
  63         __u64 valid = 0;
  64         int eadatalen = 0, rc;
  65         struct inode *inode = NULL;
  66         struct lustre_id iid;
  67
  68         id_ino(&iid) = (__u64)ino;
  69         id_gen(&iid) = generation;
  70         inode = ILOOKUP(sb, ino, ll_nfs_test_inode, &iid);
  71
  72         if (inode)
  73                 return inode;
  74         if (S_ISREG(mode)) {
  75                 eadatalen = obd_size_diskmd(sbi->ll_dt_exp, NULL);
  76                 valid |= OBD_MD_FLEASIZE;
  77         }
  78         id_type(&id) = mode;
  79         id_ino(&id) = (__u64)ino;
  80         id_gen(&id) = generation;
  81
  82         rc = md_getattr(sbi->ll_md_exp, &id, valid, NULL, NULL, 0,
  83                         eadatalen, NULL, &req);
  84         if (rc) {
  85                 CERROR("failure %d inode %lu\n", rc, ino);
  86                 return ERR_PTR(rc);
  87         }
  88
  89         rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
  90                            &inode, req, 0, sb);
  91         if (rc) {
  92                 ptlrpc_req_finished(req);
  93                 return ERR_PTR(rc);
  94         }
  95         ptlrpc_req_finished(req);
  96
  97         return inode;
  98 }
  99
 100 extern struct dentry_operations ll_d_ops;
 101
 102 static struct dentry *ll_iget_for_nfs(struct super_block *sb, unsigned long ino,
 103                                       __u32 generation, umode_t mode)
 104 {
 105         struct inode *inode;
 106         struct dentry *result;
 107         struct list_head *lp;
 108
 109         if (ino == 0)
 110                 return ERR_PTR(-ESTALE);
 111
 112         inode = search_inode_for_lustre(sb, ino, generation, mode);
 113         if (IS_ERR(inode)) {
 114                 return ERR_PTR(PTR_ERR(inode));
 115         }
 116         if (is_bad_inode(inode) ||
 117             (generation && inode->i_generation != generation)){
 118                 /* we didn't find the right inode.. */
 119                 CERROR(" Inode %lu, Bad count: %lu %d or version  %u %u\n",
 120                        inode->i_ino, (unsigned long)inode->i_nlink,
 121                        atomic_read(&inode->i_count), inode->i_generation,
 122                        generation);
 123                 iput(inode);
 124                 return ERR_PTR(-ESTALE);
 125         }
 126
 127         /* now to find a dentry.
 128          * If possible, get a well-connected one
 129          */
 130         spin_lock(&dcache_lock);
 131         for (lp = inode->i_dentry.next; lp != &inode->i_dentry ; lp=lp->next) {
 132                 result = list_entry(lp,struct dentry, d_alias);
 133                 if (!(result->d_flags & DCACHE_DISCONNECTED)) {
 134                         dget_locked(result);
 135                         ll_set_dflags(result, DCACHE_REFERENCED);
 136                         spin_unlock(&dcache_lock);
 137                         iput(inode);
 138                         return result;
 139                 }
 140         }
 141         spin_unlock(&dcache_lock);
 142         result = d_alloc_root(inode);
 143         if (result == NULL) {
 144                 iput(inode);
 145                 return ERR_PTR(-ENOMEM);
 146         }
 147         result->d_flags |= DCACHE_DISCONNECTED;
 148
 149         ll_set_dd(result);
 150         result->d_op = &ll_d_ops;
 151         return result;
 152 }
 153
 154 struct dentry *ll_fh_to_dentry(struct super_block *sb, __u32 *data, int len,
 155                                int fhtype, int parent)
 156 {
 157         switch (fhtype) {
 158                 case 2:
 159                         if (len < 5)
 160                                 break;
 161                         if (parent)
 162                                 return ll_iget_for_nfs(sb, data[3], 0, data[4]);
 163                 case 1:
 164                         if (len < 3)
 165                                 break;
 166                         if (parent)
 167                                 break;
 168                         return ll_iget_for_nfs(sb, data[0], data[1], data[2]);
 169                 default: break;
 170         }
 171         return ERR_PTR(-EINVAL);
 172 }
 173
 174 int ll_dentry_to_fh(struct dentry *dentry, __u32 *datap, int *lenp,
 175                     int need_parent)
 176 {
 177         if (*lenp < 3)
 178                 return 255;
 179         *datap++ = dentry->d_inode->i_ino;
 180         *datap++ = dentry->d_inode->i_generation;
 181         *datap++ = (__u32)(S_IFMT & dentry->d_inode->i_mode);
 182
 183         if (*lenp == 3 || S_ISDIR(dentry->d_inode->i_mode)) {
 184                 *lenp = 3;
 185                 return 1;
 186         }
 187         if (dentry->d_parent) {
 188                 *datap++ = dentry->d_parent->d_inode->i_ino;
 189                 *datap++ = (__u32)(S_IFMT & dentry->d_parent->d_inode->i_mode);
 190
 191                 *lenp = 5;
 192                 return 2;
 193         }
 194         *lenp = 3;
 195         return 1;
 196 }