1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * export.c 5 * 6 * Functions to facilitate NFS exporting 7 * 8 * Copyright (C) 2002, 2005 Oracle. All rights reserved. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public 12 * License as published by the Free Software Foundation; either 13 * version 2 of the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public 21 * License along with this program; if not, write to the 22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 23 * Boston, MA 021110-1307, USA. 24 */ 25 26 #include <linux/fs.h> 27 #include <linux/types.h> 28 29 #define MLOG_MASK_PREFIX ML_EXPORT 30 #include <cluster/masklog.h> 31 32 #include "ocfs2.h" 33 34 #include "alloc.h" 35 #include "dir.h" 36 #include "dlmglue.h" 37 #include "dcache.h" 38 #include "export.h" 39 #include "inode.h" 40 41 #include "buffer_head_io.h" 42 #include "suballoc.h" 43 44 struct ocfs2_inode_handle 45 { 46 u64 ih_blkno; 47 u32 ih_generation; 48 }; 49 50 static struct dentry *ocfs2_get_dentry(struct super_block *sb, 51 struct ocfs2_inode_handle *handle) 52 { 53 struct inode *inode; 54 struct ocfs2_super *osb = OCFS2_SB(sb); 55 u64 blkno = handle->ih_blkno; 56 int status, set; 57 struct dentry *result; 58 59 mlog_entry("(0x%p, 0x%p)\n", sb, handle); 60 61 if (blkno == 0) { 62 mlog(0, "nfs wants inode with blkno: 0\n"); 63 result = ERR_PTR(-ESTALE); 64 goto bail; 65 } 66 67 inode = ocfs2_ilookup(sb, blkno); 68 /* 69 * If the inode exists in memory, we only need to check it's 70 * generation number 71 */ 72 if (inode) 73 goto check_gen; 74 75 /* 76 * This will synchronize us against ocfs2_delete_inode() on 77 * all nodes 78 */ 79 status = ocfs2_nfs_sync_lock(osb, 1); 80 if (status < 0) { 81 mlog(ML_ERROR, "getting nfs sync lock(EX) failed %d\n", status); 82 goto check_err; 83 } 84 85 status = ocfs2_test_inode_bit(osb, blkno, &set); 86 if (status < 0) { 87 if (status == -EINVAL) { 88 /* 89 * The blkno NFS gave us doesn't even show up 90 * as an inode, we return -ESTALE to be 91 * nice 92 */ 93 mlog(0, "test inode bit failed %d\n", status); 94 status = -ESTALE; 95 } else { 96 mlog(ML_ERROR, "test inode bit failed %d\n", status); 97 } 98 goto unlock_nfs_sync; 99 } 100 101 /* If the inode allocator bit is clear, this inode must be stale */ 102 if (!set) { 103 mlog(0, "inode %llu suballoc bit is clear\n", 104 (unsigned long long)blkno); 105 status = -ESTALE; 106 goto unlock_nfs_sync; 107 } 108 109 inode = ocfs2_iget(osb, blkno, 0, 0); 110 111 unlock_nfs_sync: 112 ocfs2_nfs_sync_unlock(osb, 1); 113 114 check_err: 115 if (status < 0) { 116 if (status == -ESTALE) { 117 mlog(0, "stale inode ino: %llu generation: %u\n", 118 (unsigned long long)blkno, handle->ih_generation); 119 } 120 result = ERR_PTR(status); 121 goto bail; 122 } 123 124 if (IS_ERR(inode)) { 125 mlog_errno(PTR_ERR(inode)); 126 result = (void *)inode; 127 goto bail; 128 } 129 130 check_gen: 131 if (handle->ih_generation != inode->i_generation) { 132 iput(inode); 133 mlog(0, "stale inode ino: %llu generation: %u\n", 134 (unsigned long long)blkno, handle->ih_generation); 135 result = ERR_PTR(-ESTALE); 136 goto bail; 137 } 138 139 result = d_obtain_alias(inode); 140 if (IS_ERR(result)) 141 mlog_errno(PTR_ERR(result)); 142 143 bail: 144 mlog_exit_ptr(result); 145 return result; 146 } 147 148 static struct dentry *ocfs2_get_parent(struct dentry *child) 149 { 150 int status; 151 u64 blkno; 152 struct dentry *parent; 153 struct inode *dir = child->d_inode; 154 155 mlog_entry("(0x%p, '%.*s')\n", child, 156 child->d_name.len, child->d_name.name); 157 158 mlog(0, "find parent of directory %llu\n", 159 (unsigned long long)OCFS2_I(dir)->ip_blkno); 160 161 status = ocfs2_inode_lock(dir, NULL, 0); 162 if (status < 0) { 163 if (status != -ENOENT) 164 mlog_errno(status); 165 parent = ERR_PTR(status); 166 goto bail; 167 } 168 169 status = ocfs2_lookup_ino_from_name(dir, "..", 2, &blkno); 170 if (status < 0) { 171 parent = ERR_PTR(-ENOENT); 172 goto bail_unlock; 173 } 174 175 parent = d_obtain_alias(ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0)); 176 177 bail_unlock: 178 ocfs2_inode_unlock(dir, 0); 179 180 bail: 181 mlog_exit_ptr(parent); 182 183 return parent; 184 } 185 186 static int ocfs2_encode_fh(struct dentry *dentry, u32 *fh_in, int *max_len, 187 int connectable) 188 { 189 struct inode *inode = dentry->d_inode; 190 int len = *max_len; 191 int type = 1; 192 u64 blkno; 193 u32 generation; 194 __le32 *fh = (__force __le32 *) fh_in; 195 196 mlog_entry("(0x%p, '%.*s', 0x%p, %d, %d)\n", dentry, 197 dentry->d_name.len, dentry->d_name.name, 198 fh, len, connectable); 199 200 if (len < 3 || (connectable && len < 6)) { 201 mlog(ML_ERROR, "fh buffer is too small for encoding\n"); 202 type = 255; 203 goto bail; 204 } 205 206 blkno = OCFS2_I(inode)->ip_blkno; 207 generation = inode->i_generation; 208 209 mlog(0, "Encoding fh: blkno: %llu, generation: %u\n", 210 (unsigned long long)blkno, generation); 211 212 len = 3; 213 fh[0] = cpu_to_le32((u32)(blkno >> 32)); 214 fh[1] = cpu_to_le32((u32)(blkno & 0xffffffff)); 215 fh[2] = cpu_to_le32(generation); 216 217 if (connectable && !S_ISDIR(inode->i_mode)) { 218 struct inode *parent; 219 220 spin_lock(&dentry->d_lock); 221 222 parent = dentry->d_parent->d_inode; 223 blkno = OCFS2_I(parent)->ip_blkno; 224 generation = parent->i_generation; 225 226 fh[3] = cpu_to_le32((u32)(blkno >> 32)); 227 fh[4] = cpu_to_le32((u32)(blkno & 0xffffffff)); 228 fh[5] = cpu_to_le32(generation); 229 230 spin_unlock(&dentry->d_lock); 231 232 len = 6; 233 type = 2; 234 235 mlog(0, "Encoding parent: blkno: %llu, generation: %u\n", 236 (unsigned long long)blkno, generation); 237 } 238 239 *max_len = len; 240 241 bail: 242 mlog_exit(type); 243 return type; 244 } 245 246 static struct dentry *ocfs2_fh_to_dentry(struct super_block *sb, 247 struct fid *fid, int fh_len, int fh_type) 248 { 249 struct ocfs2_inode_handle handle; 250 251 if (fh_len < 3 || fh_type > 2) 252 return NULL; 253 254 handle.ih_blkno = (u64)le32_to_cpu(fid->raw[0]) << 32; 255 handle.ih_blkno |= (u64)le32_to_cpu(fid->raw[1]); 256 handle.ih_generation = le32_to_cpu(fid->raw[2]); 257 return ocfs2_get_dentry(sb, &handle); 258 } 259 260 static struct dentry *ocfs2_fh_to_parent(struct super_block *sb, 261 struct fid *fid, int fh_len, int fh_type) 262 { 263 struct ocfs2_inode_handle parent; 264 265 if (fh_type != 2 || fh_len < 6) 266 return NULL; 267 268 parent.ih_blkno = (u64)le32_to_cpu(fid->raw[3]) << 32; 269 parent.ih_blkno |= (u64)le32_to_cpu(fid->raw[4]); 270 parent.ih_generation = le32_to_cpu(fid->raw[5]); 271 return ocfs2_get_dentry(sb, &parent); 272 } 273 274 const struct export_operations ocfs2_export_ops = { 275 .encode_fh = ocfs2_encode_fh, 276 .fh_to_dentry = ocfs2_fh_to_dentry, 277 .fh_to_parent = ocfs2_fh_to_parent, 278 .get_parent = ocfs2_get_parent, 279 }; 280