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