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", blkno); 104 status = -ESTALE; 105 goto unlock_nfs_sync; 106 } 107 108 inode = ocfs2_iget(osb, blkno, 0, 0); 109 110 unlock_nfs_sync: 111 ocfs2_nfs_sync_unlock(osb, 1); 112 113 check_err: 114 if (status < 0) { 115 if (status == -ESTALE) { 116 mlog(0, "stale inode ino: %llu generation: %u\n", 117 blkno, handle->ih_generation); 118 } 119 result = ERR_PTR(status); 120 goto bail; 121 } 122 123 if (IS_ERR(inode)) { 124 mlog_errno(PTR_ERR(inode)); 125 result = (void *)inode; 126 goto bail; 127 } 128 129 check_gen: 130 if (handle->ih_generation != inode->i_generation) { 131 iput(inode); 132 mlog(0, "stale inode ino: %llu generation: %u\n", blkno, 133 handle->ih_generation); 134 result = ERR_PTR(-ESTALE); 135 goto bail; 136 } 137 138 result = d_obtain_alias(inode); 139 if (!IS_ERR(result)) 140 result->d_op = &ocfs2_dentry_ops; 141 else 142 mlog_errno(PTR_ERR(result)); 143 144 bail: 145 mlog_exit_ptr(result); 146 return result; 147 } 148 149 static struct dentry *ocfs2_get_parent(struct dentry *child) 150 { 151 int status; 152 u64 blkno; 153 struct dentry *parent; 154 struct inode *dir = child->d_inode; 155 156 mlog_entry("(0x%p, '%.*s')\n", child, 157 child->d_name.len, child->d_name.name); 158 159 mlog(0, "find parent of directory %llu\n", 160 (unsigned long long)OCFS2_I(dir)->ip_blkno); 161 162 status = ocfs2_inode_lock(dir, NULL, 0); 163 if (status < 0) { 164 if (status != -ENOENT) 165 mlog_errno(status); 166 parent = ERR_PTR(status); 167 goto bail; 168 } 169 170 status = ocfs2_lookup_ino_from_name(dir, "..", 2, &blkno); 171 if (status < 0) { 172 parent = ERR_PTR(-ENOENT); 173 goto bail_unlock; 174 } 175 176 parent = d_obtain_alias(ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0)); 177 if (!IS_ERR(parent)) 178 parent->d_op = &ocfs2_dentry_ops; 179 180 bail_unlock: 181 ocfs2_inode_unlock(dir, 0); 182 183 bail: 184 mlog_exit_ptr(parent); 185 186 return parent; 187 } 188 189 static int ocfs2_encode_fh(struct dentry *dentry, u32 *fh_in, int *max_len, 190 int connectable) 191 { 192 struct inode *inode = dentry->d_inode; 193 int len = *max_len; 194 int type = 1; 195 u64 blkno; 196 u32 generation; 197 __le32 *fh = (__force __le32 *) fh_in; 198 199 mlog_entry("(0x%p, '%.*s', 0x%p, %d, %d)\n", dentry, 200 dentry->d_name.len, dentry->d_name.name, 201 fh, len, connectable); 202 203 if (len < 3 || (connectable && len < 6)) { 204 mlog(ML_ERROR, "fh buffer is too small for encoding\n"); 205 type = 255; 206 goto bail; 207 } 208 209 blkno = OCFS2_I(inode)->ip_blkno; 210 generation = inode->i_generation; 211 212 mlog(0, "Encoding fh: blkno: %llu, generation: %u\n", 213 (unsigned long long)blkno, generation); 214 215 len = 3; 216 fh[0] = cpu_to_le32((u32)(blkno >> 32)); 217 fh[1] = cpu_to_le32((u32)(blkno & 0xffffffff)); 218 fh[2] = cpu_to_le32(generation); 219 220 if (connectable && !S_ISDIR(inode->i_mode)) { 221 struct inode *parent; 222 223 spin_lock(&dentry->d_lock); 224 225 parent = dentry->d_parent->d_inode; 226 blkno = OCFS2_I(parent)->ip_blkno; 227 generation = parent->i_generation; 228 229 fh[3] = cpu_to_le32((u32)(blkno >> 32)); 230 fh[4] = cpu_to_le32((u32)(blkno & 0xffffffff)); 231 fh[5] = cpu_to_le32(generation); 232 233 spin_unlock(&dentry->d_lock); 234 235 len = 6; 236 type = 2; 237 238 mlog(0, "Encoding parent: blkno: %llu, generation: %u\n", 239 (unsigned long long)blkno, generation); 240 } 241 242 *max_len = len; 243 244 bail: 245 mlog_exit(type); 246 return type; 247 } 248 249 static struct dentry *ocfs2_fh_to_dentry(struct super_block *sb, 250 struct fid *fid, int fh_len, int fh_type) 251 { 252 struct ocfs2_inode_handle handle; 253 254 if (fh_len < 3 || fh_type > 2) 255 return NULL; 256 257 handle.ih_blkno = (u64)le32_to_cpu(fid->raw[0]) << 32; 258 handle.ih_blkno |= (u64)le32_to_cpu(fid->raw[1]); 259 handle.ih_generation = le32_to_cpu(fid->raw[2]); 260 return ocfs2_get_dentry(sb, &handle); 261 } 262 263 static struct dentry *ocfs2_fh_to_parent(struct super_block *sb, 264 struct fid *fid, int fh_len, int fh_type) 265 { 266 struct ocfs2_inode_handle parent; 267 268 if (fh_type != 2 || fh_len < 6) 269 return NULL; 270 271 parent.ih_blkno = (u64)le32_to_cpu(fid->raw[3]) << 32; 272 parent.ih_blkno |= (u64)le32_to_cpu(fid->raw[4]); 273 parent.ih_generation = le32_to_cpu(fid->raw[5]); 274 return ocfs2_get_dentry(sb, &parent); 275 } 276 277 const struct export_operations ocfs2_export_ops = { 278 .encode_fh = ocfs2_encode_fh, 279 .fh_to_dentry = ocfs2_fh_to_dentry, 280 .fh_to_parent = ocfs2_fh_to_parent, 281 .get_parent = ocfs2_get_parent, 282 }; 283