David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. |
Steven Whitehouse | 3a8a9a1 | 2006-05-18 15:09:15 -0400 | [diff] [blame] | 3 | * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 4 | * |
| 5 | * This copyrighted material is made available to anyone wishing to use, |
| 6 | * modify, copy, or redistribute it subject to the terms and conditions |
| 7 | * of the GNU General Public License v.2. |
| 8 | */ |
| 9 | |
| 10 | #include <linux/sched.h> |
| 11 | #include <linux/slab.h> |
| 12 | #include <linux/spinlock.h> |
| 13 | #include <linux/completion.h> |
| 14 | #include <linux/buffer_head.h> |
Steven Whitehouse | 5c676f6 | 2006-02-27 17:23:27 -0500 | [diff] [blame] | 15 | #include <linux/gfs2_ondisk.h> |
Steven Whitehouse | 71b86f5 | 2006-03-28 14:14:04 -0500 | [diff] [blame] | 16 | #include <linux/crc32.h> |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 17 | |
| 18 | #include "gfs2.h" |
Steven Whitehouse | 5c676f6 | 2006-02-27 17:23:27 -0500 | [diff] [blame] | 19 | #include "lm_interface.h" |
| 20 | #include "incore.h" |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 21 | #include "dir.h" |
| 22 | #include "glock.h" |
| 23 | #include "glops.h" |
| 24 | #include "inode.h" |
| 25 | #include "ops_export.h" |
| 26 | #include "rgrp.h" |
Steven Whitehouse | c752666 | 2006-03-20 12:30:04 -0500 | [diff] [blame] | 27 | #include "util.h" |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 28 | |
| 29 | static struct dentry *gfs2_decode_fh(struct super_block *sb, |
| 30 | __u32 *fh, |
| 31 | int fh_len, |
| 32 | int fh_type, |
| 33 | int (*acceptable)(void *context, |
| 34 | struct dentry *dentry), |
| 35 | void *context) |
| 36 | { |
| 37 | struct gfs2_inum this, parent; |
| 38 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 39 | if (fh_type != fh_len) |
| 40 | return NULL; |
| 41 | |
| 42 | memset(&parent, 0, sizeof(struct gfs2_inum)); |
| 43 | |
| 44 | switch (fh_type) { |
| 45 | case 8: |
| 46 | parent.no_formal_ino = ((uint64_t)be32_to_cpu(fh[4])) << 32; |
| 47 | parent.no_formal_ino |= be32_to_cpu(fh[5]); |
| 48 | parent.no_addr = ((uint64_t)be32_to_cpu(fh[6])) << 32; |
| 49 | parent.no_addr |= be32_to_cpu(fh[7]); |
| 50 | case 4: |
| 51 | this.no_formal_ino = ((uint64_t)be32_to_cpu(fh[0])) << 32; |
| 52 | this.no_formal_ino |= be32_to_cpu(fh[1]); |
| 53 | this.no_addr = ((uint64_t)be32_to_cpu(fh[2])) << 32; |
| 54 | this.no_addr |= be32_to_cpu(fh[3]); |
| 55 | break; |
| 56 | default: |
| 57 | return NULL; |
| 58 | } |
| 59 | |
| 60 | return gfs2_export_ops.find_exported_dentry(sb, &this, &parent, |
| 61 | acceptable, context); |
| 62 | } |
| 63 | |
| 64 | static int gfs2_encode_fh(struct dentry *dentry, __u32 *fh, int *len, |
| 65 | int connectable) |
| 66 | { |
| 67 | struct inode *inode = dentry->d_inode; |
Steven Whitehouse | c9fd430 | 2006-03-01 15:31:02 -0500 | [diff] [blame] | 68 | struct super_block *sb = inode->i_sb; |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 69 | struct gfs2_inode *ip = GFS2_I(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 70 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 71 | if (*len < 4 || (connectable && *len < 8)) |
| 72 | return 255; |
| 73 | |
| 74 | fh[0] = ip->i_num.no_formal_ino >> 32; |
| 75 | fh[0] = cpu_to_be32(fh[0]); |
| 76 | fh[1] = ip->i_num.no_formal_ino & 0xFFFFFFFF; |
| 77 | fh[1] = cpu_to_be32(fh[1]); |
| 78 | fh[2] = ip->i_num.no_addr >> 32; |
| 79 | fh[2] = cpu_to_be32(fh[2]); |
| 80 | fh[3] = ip->i_num.no_addr & 0xFFFFFFFF; |
| 81 | fh[3] = cpu_to_be32(fh[3]); |
| 82 | *len = 4; |
| 83 | |
Steven Whitehouse | c9fd430 | 2006-03-01 15:31:02 -0500 | [diff] [blame] | 84 | if (!connectable || inode == sb->s_root->d_inode) |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 85 | return *len; |
| 86 | |
| 87 | spin_lock(&dentry->d_lock); |
| 88 | inode = dentry->d_parent->d_inode; |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 89 | ip = GFS2_I(inode); |
| 90 | igrab(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 91 | spin_unlock(&dentry->d_lock); |
| 92 | |
| 93 | fh[4] = ip->i_num.no_formal_ino >> 32; |
| 94 | fh[4] = cpu_to_be32(fh[4]); |
| 95 | fh[5] = ip->i_num.no_formal_ino & 0xFFFFFFFF; |
| 96 | fh[5] = cpu_to_be32(fh[5]); |
| 97 | fh[6] = ip->i_num.no_addr >> 32; |
| 98 | fh[6] = cpu_to_be32(fh[6]); |
| 99 | fh[7] = ip->i_num.no_addr & 0xFFFFFFFF; |
| 100 | fh[7] = cpu_to_be32(fh[7]); |
| 101 | *len = 8; |
| 102 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 103 | iput(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 104 | |
| 105 | return *len; |
| 106 | } |
| 107 | |
| 108 | struct get_name_filldir { |
| 109 | struct gfs2_inum inum; |
| 110 | char *name; |
| 111 | }; |
| 112 | |
| 113 | static int get_name_filldir(void *opaque, const char *name, unsigned int length, |
| 114 | uint64_t offset, struct gfs2_inum *inum, |
| 115 | unsigned int type) |
| 116 | { |
| 117 | struct get_name_filldir *gnfd = (struct get_name_filldir *)opaque; |
| 118 | |
| 119 | if (!gfs2_inum_equal(inum, &gnfd->inum)) |
| 120 | return 0; |
| 121 | |
| 122 | memcpy(gnfd->name, name, length); |
| 123 | gnfd->name[length] = 0; |
| 124 | |
| 125 | return 1; |
| 126 | } |
| 127 | |
| 128 | static int gfs2_get_name(struct dentry *parent, char *name, |
| 129 | struct dentry *child) |
| 130 | { |
| 131 | struct inode *dir = parent->d_inode; |
| 132 | struct inode *inode = child->d_inode; |
| 133 | struct gfs2_inode *dip, *ip; |
| 134 | struct get_name_filldir gnfd; |
| 135 | struct gfs2_holder gh; |
| 136 | uint64_t offset = 0; |
| 137 | int error; |
| 138 | |
| 139 | if (!dir) |
| 140 | return -EINVAL; |
| 141 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 142 | if (!S_ISDIR(dir->i_mode) || !inode) |
| 143 | return -EINVAL; |
| 144 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 145 | dip = GFS2_I(dir); |
| 146 | ip = GFS2_I(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 147 | |
| 148 | *name = 0; |
| 149 | gnfd.inum = ip->i_num; |
| 150 | gnfd.name = name; |
| 151 | |
| 152 | error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh); |
| 153 | if (error) |
| 154 | return error; |
| 155 | |
Steven Whitehouse | 71b86f5 | 2006-03-28 14:14:04 -0500 | [diff] [blame] | 156 | error = gfs2_dir_read(dir, &offset, &gnfd, get_name_filldir); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 157 | |
| 158 | gfs2_glock_dq_uninit(&gh); |
| 159 | |
| 160 | if (!error && !*name) |
| 161 | error = -ENOENT; |
| 162 | |
| 163 | return error; |
| 164 | } |
| 165 | |
| 166 | static struct dentry *gfs2_get_parent(struct dentry *child) |
| 167 | { |
Steven Whitehouse | 71b86f5 | 2006-03-28 14:14:04 -0500 | [diff] [blame] | 168 | struct qstr dotdot; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 169 | struct inode *inode; |
| 170 | struct dentry *dentry; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 171 | |
Steven Whitehouse | 71b86f5 | 2006-03-28 14:14:04 -0500 | [diff] [blame] | 172 | gfs2_str2qstr(&dotdot, ".."); |
Steven Whitehouse | c752666 | 2006-03-20 12:30:04 -0500 | [diff] [blame] | 173 | inode = gfs2_lookupi(child->d_inode, &dotdot, 1, NULL); |
| 174 | |
| 175 | if (!inode) |
| 176 | return ERR_PTR(-ENOENT); |
| 177 | if (IS_ERR(inode)) |
| 178 | return ERR_PTR(PTR_ERR(inode)); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 179 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 180 | dentry = d_alloc_anon(inode); |
| 181 | if (!dentry) { |
| 182 | iput(inode); |
| 183 | return ERR_PTR(-ENOMEM); |
| 184 | } |
| 185 | |
| 186 | return dentry; |
| 187 | } |
| 188 | |
| 189 | static struct dentry *gfs2_get_dentry(struct super_block *sb, void *inum_p) |
| 190 | { |
Steven Whitehouse | 5c676f6 | 2006-02-27 17:23:27 -0500 | [diff] [blame] | 191 | struct gfs2_sbd *sdp = sb->s_fs_info; |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 192 | struct gfs2_inum *inum = inum_p; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 193 | struct gfs2_holder i_gh, ri_gh, rgd_gh; |
| 194 | struct gfs2_rgrpd *rgd; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 195 | struct inode *inode; |
| 196 | struct dentry *dentry; |
| 197 | int error; |
| 198 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 199 | /* System files? */ |
| 200 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 201 | inode = gfs2_ilookup(sb, inum); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 202 | if (inode) { |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 203 | if (GFS2_I(inode)->i_num.no_formal_ino != inum->no_formal_ino) { |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 204 | iput(inode); |
| 205 | return ERR_PTR(-ESTALE); |
| 206 | } |
| 207 | goto out_inode; |
| 208 | } |
| 209 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 210 | error = gfs2_glock_nq_num(sdp, inum->no_addr, &gfs2_inode_glops, |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 211 | LM_ST_SHARED, LM_FLAG_ANY | GL_LOCAL_EXCL, |
| 212 | &i_gh); |
| 213 | if (error) |
| 214 | return ERR_PTR(error); |
| 215 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 216 | error = gfs2_rindex_hold(sdp, &ri_gh); |
| 217 | if (error) |
| 218 | goto fail; |
| 219 | |
| 220 | error = -EINVAL; |
| 221 | rgd = gfs2_blk2rgrpd(sdp, inum->no_addr); |
| 222 | if (!rgd) |
| 223 | goto fail_rindex; |
| 224 | |
| 225 | error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh); |
| 226 | if (error) |
| 227 | goto fail_rindex; |
| 228 | |
| 229 | error = -ESTALE; |
| 230 | if (gfs2_get_block_type(rgd, inum->no_addr) != GFS2_BLKST_DINODE) |
| 231 | goto fail_rgd; |
| 232 | |
| 233 | gfs2_glock_dq_uninit(&rgd_gh); |
| 234 | gfs2_glock_dq_uninit(&ri_gh); |
| 235 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 236 | inode = gfs2_inode_lookup(sb, inum, DT_UNKNOWN); |
| 237 | if (!inode) |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 238 | goto fail; |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 239 | if (IS_ERR(inode)) { |
| 240 | error = PTR_ERR(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 241 | goto fail; |
| 242 | } |
| 243 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 244 | error = gfs2_inode_refresh(GFS2_I(inode)); |
| 245 | if (error) { |
| 246 | iput(inode); |
| 247 | goto fail; |
| 248 | } |
| 249 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 250 | error = -EIO; |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 251 | if (GFS2_I(inode)->i_di.di_flags & GFS2_DIF_SYSTEM) { |
| 252 | iput(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 253 | goto fail; |
| 254 | } |
| 255 | |
| 256 | gfs2_glock_dq_uninit(&i_gh); |
| 257 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 258 | out_inode: |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 259 | dentry = d_alloc_anon(inode); |
| 260 | if (!dentry) { |
| 261 | iput(inode); |
| 262 | return ERR_PTR(-ENOMEM); |
| 263 | } |
| 264 | |
| 265 | return dentry; |
| 266 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 267 | fail_rgd: |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 268 | gfs2_glock_dq_uninit(&rgd_gh); |
| 269 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 270 | fail_rindex: |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 271 | gfs2_glock_dq_uninit(&ri_gh); |
| 272 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 273 | fail: |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 274 | gfs2_glock_dq_uninit(&i_gh); |
| 275 | return ERR_PTR(error); |
| 276 | } |
| 277 | |
| 278 | struct export_operations gfs2_export_ops = { |
| 279 | .decode_fh = gfs2_decode_fh, |
| 280 | .encode_fh = gfs2_encode_fh, |
| 281 | .get_name = gfs2_get_name, |
| 282 | .get_parent = gfs2_get_parent, |
| 283 | .get_dentry = gfs2_get_dentry, |
| 284 | }; |
| 285 | |