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 |
Steven Whitehouse | e9fc2aa | 2006-09-01 11:05:15 -0400 | [diff] [blame] | 7 | * of the GNU General Public License version 2. |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 8 | */ |
| 9 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 10 | #include <linux/slab.h> |
| 11 | #include <linux/spinlock.h> |
| 12 | #include <linux/completion.h> |
| 13 | #include <linux/buffer_head.h> |
Christoph Hellwig | a569425 | 2007-07-17 04:04:28 -0700 | [diff] [blame] | 14 | #include <linux/exportfs.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> |
Fabio Massimo Di Nitto | 7d30859 | 2006-09-19 07:56:29 +0200 | [diff] [blame] | 17 | #include <linux/lm_interface.h> |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 18 | |
| 19 | #include "gfs2.h" |
Steven Whitehouse | 5c676f6 | 2006-02-27 17:23:27 -0500 | [diff] [blame] | 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" |
Robert Peterson | 7083146 | 2007-01-11 13:25:00 -0600 | [diff] [blame] | 25 | #include "ops_dentry.h" |
Steven Whitehouse | bb8d8a6 | 2007-06-01 14:11:58 +0100 | [diff] [blame] | 26 | #include "ops_fstype.h" |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 27 | #include "rgrp.h" |
Steven Whitehouse | c752666 | 2006-03-20 12:30:04 -0500 | [diff] [blame] | 28 | #include "util.h" |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 29 | |
Steven Whitehouse | bb8d8a6 | 2007-06-01 14:11:58 +0100 | [diff] [blame] | 30 | #define GFS2_SMALL_FH_SIZE 4 |
Wendy Cheng | 35dcc52 | 2007-06-27 17:07:53 -0400 | [diff] [blame] | 31 | #define GFS2_LARGE_FH_SIZE 8 |
Steven Whitehouse | 3ebf449 | 2007-07-10 12:28:27 +0100 | [diff] [blame] | 32 | #define GFS2_OLD_FH_SIZE 10 |
Steven Whitehouse | bb8d8a6 | 2007-06-01 14:11:58 +0100 | [diff] [blame] | 33 | |
Al Viro | b44b84d | 2006-10-14 10:46:30 -0400 | [diff] [blame] | 34 | static int gfs2_encode_fh(struct dentry *dentry, __u32 *p, int *len, |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 35 | int connectable) |
| 36 | { |
Al Viro | b44b84d | 2006-10-14 10:46:30 -0400 | [diff] [blame] | 37 | __be32 *fh = (__force __be32 *)p; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 38 | struct inode *inode = dentry->d_inode; |
Steven Whitehouse | c9fd430 | 2006-03-01 15:31:02 -0500 | [diff] [blame] | 39 | struct super_block *sb = inode->i_sb; |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 40 | struct gfs2_inode *ip = GFS2_I(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 41 | |
Steven Whitehouse | 5acd396 | 2006-09-04 16:16:45 -0400 | [diff] [blame] | 42 | if (*len < GFS2_SMALL_FH_SIZE || |
| 43 | (connectable && *len < GFS2_LARGE_FH_SIZE)) |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 44 | return 255; |
| 45 | |
Steven Whitehouse | dbb7cae | 2007-05-15 15:37:50 +0100 | [diff] [blame] | 46 | fh[0] = cpu_to_be32(ip->i_no_formal_ino >> 32); |
| 47 | fh[1] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF); |
| 48 | fh[2] = cpu_to_be32(ip->i_no_addr >> 32); |
| 49 | fh[3] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF); |
Steven Whitehouse | 5acd396 | 2006-09-04 16:16:45 -0400 | [diff] [blame] | 50 | *len = GFS2_SMALL_FH_SIZE; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 51 | |
Steven Whitehouse | c9fd430 | 2006-03-01 15:31:02 -0500 | [diff] [blame] | 52 | if (!connectable || inode == sb->s_root->d_inode) |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 53 | return *len; |
| 54 | |
| 55 | spin_lock(&dentry->d_lock); |
| 56 | inode = dentry->d_parent->d_inode; |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 57 | ip = GFS2_I(inode); |
| 58 | igrab(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 59 | spin_unlock(&dentry->d_lock); |
| 60 | |
Steven Whitehouse | dbb7cae | 2007-05-15 15:37:50 +0100 | [diff] [blame] | 61 | fh[4] = cpu_to_be32(ip->i_no_formal_ino >> 32); |
| 62 | fh[5] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF); |
| 63 | fh[6] = cpu_to_be32(ip->i_no_addr >> 32); |
| 64 | fh[7] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF); |
Steven Whitehouse | 5acd396 | 2006-09-04 16:16:45 -0400 | [diff] [blame] | 65 | *len = GFS2_LARGE_FH_SIZE; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 66 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 67 | iput(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 68 | |
| 69 | return *len; |
| 70 | } |
| 71 | |
| 72 | struct get_name_filldir { |
Al Viro | 629a21e | 2006-10-13 22:51:24 -0400 | [diff] [blame] | 73 | struct gfs2_inum_host inum; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 74 | char *name; |
| 75 | }; |
| 76 | |
Steven Whitehouse | 3699e3a | 2007-01-17 15:09:20 +0000 | [diff] [blame] | 77 | static int get_name_filldir(void *opaque, const char *name, int length, |
| 78 | loff_t offset, u64 inum, unsigned int type) |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 79 | { |
Steven Whitehouse | 3699e3a | 2007-01-17 15:09:20 +0000 | [diff] [blame] | 80 | struct get_name_filldir *gnfd = opaque; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 81 | |
Steven Whitehouse | 3699e3a | 2007-01-17 15:09:20 +0000 | [diff] [blame] | 82 | if (inum != gnfd->inum.no_addr) |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 83 | return 0; |
| 84 | |
| 85 | memcpy(gnfd->name, name, length); |
| 86 | gnfd->name[length] = 0; |
| 87 | |
| 88 | return 1; |
| 89 | } |
| 90 | |
| 91 | static int gfs2_get_name(struct dentry *parent, char *name, |
| 92 | struct dentry *child) |
| 93 | { |
| 94 | struct inode *dir = parent->d_inode; |
| 95 | struct inode *inode = child->d_inode; |
| 96 | struct gfs2_inode *dip, *ip; |
| 97 | struct get_name_filldir gnfd; |
| 98 | struct gfs2_holder gh; |
Steven Whitehouse | cd91549 | 2006-09-04 12:49:07 -0400 | [diff] [blame] | 99 | u64 offset = 0; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 100 | int error; |
| 101 | |
| 102 | if (!dir) |
| 103 | return -EINVAL; |
| 104 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 105 | if (!S_ISDIR(dir->i_mode) || !inode) |
| 106 | return -EINVAL; |
| 107 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 108 | dip = GFS2_I(dir); |
| 109 | ip = GFS2_I(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 110 | |
| 111 | *name = 0; |
Steven Whitehouse | dbb7cae | 2007-05-15 15:37:50 +0100 | [diff] [blame] | 112 | gnfd.inum.no_addr = ip->i_no_addr; |
| 113 | gnfd.inum.no_formal_ino = ip->i_no_formal_ino; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 114 | gnfd.name = name; |
| 115 | |
| 116 | error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh); |
| 117 | if (error) |
| 118 | return error; |
| 119 | |
Steven Whitehouse | 71b86f5 | 2006-03-28 14:14:04 -0500 | [diff] [blame] | 120 | error = gfs2_dir_read(dir, &offset, &gnfd, get_name_filldir); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 121 | |
| 122 | gfs2_glock_dq_uninit(&gh); |
| 123 | |
| 124 | if (!error && !*name) |
| 125 | error = -ENOENT; |
| 126 | |
| 127 | return error; |
| 128 | } |
| 129 | |
| 130 | static struct dentry *gfs2_get_parent(struct dentry *child) |
| 131 | { |
Steven Whitehouse | 71b86f5 | 2006-03-28 14:14:04 -0500 | [diff] [blame] | 132 | struct qstr dotdot; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 133 | struct dentry *dentry; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 134 | |
Steven Whitehouse | 7b62536 | 2006-09-05 15:56:17 -0400 | [diff] [blame] | 135 | /* |
Christoph Hellwig | 4400372 | 2008-08-11 15:49:04 +0200 | [diff] [blame^] | 136 | * XXX(hch): it would be a good idea to keep this around as a |
| 137 | * static variable. |
Steven Whitehouse | 7b62536 | 2006-09-05 15:56:17 -0400 | [diff] [blame] | 138 | */ |
Christoph Hellwig | 4400372 | 2008-08-11 15:49:04 +0200 | [diff] [blame^] | 139 | gfs2_str2qstr(&dotdot, ".."); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 140 | |
Christoph Hellwig | 4400372 | 2008-08-11 15:49:04 +0200 | [diff] [blame^] | 141 | dentry = d_obtain_alias(gfs2_lookupi(child->d_inode, &dotdot, 1)); |
| 142 | if (!IS_ERR(dentry)) |
| 143 | dentry->d_op = &gfs2_dops; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 144 | return dentry; |
| 145 | } |
| 146 | |
Christoph Hellwig | 34c0d15 | 2007-10-21 16:42:14 -0700 | [diff] [blame] | 147 | static struct dentry *gfs2_get_dentry(struct super_block *sb, |
| 148 | struct gfs2_inum_host *inum) |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 149 | { |
Steven Whitehouse | 5c676f6 | 2006-02-27 17:23:27 -0500 | [diff] [blame] | 150 | struct gfs2_sbd *sdp = sb->s_fs_info; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 151 | struct gfs2_holder i_gh, ri_gh, rgd_gh; |
| 152 | struct gfs2_rgrpd *rgd; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 153 | struct inode *inode; |
| 154 | struct dentry *dentry; |
| 155 | int error; |
| 156 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 157 | /* System files? */ |
| 158 | |
Steven Whitehouse | dbb7cae | 2007-05-15 15:37:50 +0100 | [diff] [blame] | 159 | inode = gfs2_ilookup(sb, inum->no_addr); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 160 | if (inode) { |
Steven Whitehouse | dbb7cae | 2007-05-15 15:37:50 +0100 | [diff] [blame] | 161 | if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) { |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 162 | iput(inode); |
| 163 | return ERR_PTR(-ESTALE); |
| 164 | } |
| 165 | goto out_inode; |
| 166 | } |
| 167 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 168 | error = gfs2_glock_nq_num(sdp, inum->no_addr, &gfs2_inode_glops, |
Steven Whitehouse | 1c0f487 | 2007-01-22 12:10:39 -0500 | [diff] [blame] | 169 | LM_ST_SHARED, LM_FLAG_ANY, &i_gh); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 170 | if (error) |
| 171 | return ERR_PTR(error); |
| 172 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 173 | error = gfs2_rindex_hold(sdp, &ri_gh); |
| 174 | if (error) |
| 175 | goto fail; |
| 176 | |
| 177 | error = -EINVAL; |
| 178 | rgd = gfs2_blk2rgrpd(sdp, inum->no_addr); |
| 179 | if (!rgd) |
| 180 | goto fail_rindex; |
| 181 | |
| 182 | error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh); |
| 183 | if (error) |
| 184 | goto fail_rindex; |
| 185 | |
| 186 | error = -ESTALE; |
| 187 | if (gfs2_get_block_type(rgd, inum->no_addr) != GFS2_BLKST_DINODE) |
| 188 | goto fail_rgd; |
| 189 | |
| 190 | gfs2_glock_dq_uninit(&rgd_gh); |
| 191 | gfs2_glock_dq_uninit(&ri_gh); |
| 192 | |
Wendy Cheng | 35dcc52 | 2007-06-27 17:07:53 -0400 | [diff] [blame] | 193 | inode = gfs2_inode_lookup(sb, DT_UNKNOWN, |
Wendy Cheng | bb9bcf0 | 2007-06-27 17:07:08 -0400 | [diff] [blame] | 194 | inum->no_addr, |
Benjamin Marzinski | 7a9f53b | 2007-09-18 13:33:18 -0500 | [diff] [blame] | 195 | 0, 0); |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 196 | if (IS_ERR(inode)) { |
| 197 | error = PTR_ERR(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 198 | goto fail; |
| 199 | } |
| 200 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 201 | error = gfs2_inode_refresh(GFS2_I(inode)); |
| 202 | if (error) { |
| 203 | iput(inode); |
| 204 | goto fail; |
| 205 | } |
Wendy Cheng | 35dcc52 | 2007-06-27 17:07:53 -0400 | [diff] [blame] | 206 | |
| 207 | /* Pick up the works we bypass in gfs2_inode_lookup */ |
| 208 | if (inode->i_state & I_NEW) |
| 209 | gfs2_set_iop(inode); |
| 210 | |
Steven Whitehouse | dbb7cae | 2007-05-15 15:37:50 +0100 | [diff] [blame] | 211 | if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) { |
| 212 | iput(inode); |
| 213 | goto fail; |
| 214 | } |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 215 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 216 | error = -EIO; |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 217 | if (GFS2_I(inode)->i_di.di_flags & GFS2_DIF_SYSTEM) { |
| 218 | iput(inode); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 219 | goto fail; |
| 220 | } |
| 221 | |
| 222 | gfs2_glock_dq_uninit(&i_gh); |
| 223 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 224 | out_inode: |
Christoph Hellwig | 4400372 | 2008-08-11 15:49:04 +0200 | [diff] [blame^] | 225 | dentry = d_obtain_alias(inode); |
| 226 | if (!IS_ERR(dentry)) |
| 227 | dentry->d_op = &gfs2_dops; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 228 | return dentry; |
| 229 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 230 | fail_rgd: |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 231 | gfs2_glock_dq_uninit(&rgd_gh); |
| 232 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 233 | fail_rindex: |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 234 | gfs2_glock_dq_uninit(&ri_gh); |
| 235 | |
Steven Whitehouse | feaa7bb | 2006-06-14 15:32:57 -0400 | [diff] [blame] | 236 | fail: |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 237 | gfs2_glock_dq_uninit(&i_gh); |
| 238 | return ERR_PTR(error); |
| 239 | } |
| 240 | |
Christoph Hellwig | 34c0d15 | 2007-10-21 16:42:14 -0700 | [diff] [blame] | 241 | static struct dentry *gfs2_fh_to_dentry(struct super_block *sb, struct fid *fid, |
| 242 | int fh_len, int fh_type) |
| 243 | { |
| 244 | struct gfs2_inum_host this; |
| 245 | __be32 *fh = (__force __be32 *)fid->raw; |
| 246 | |
| 247 | switch (fh_type) { |
| 248 | case GFS2_SMALL_FH_SIZE: |
| 249 | case GFS2_LARGE_FH_SIZE: |
| 250 | case GFS2_OLD_FH_SIZE: |
| 251 | this.no_formal_ino = ((u64)be32_to_cpu(fh[0])) << 32; |
| 252 | this.no_formal_ino |= be32_to_cpu(fh[1]); |
| 253 | this.no_addr = ((u64)be32_to_cpu(fh[2])) << 32; |
| 254 | this.no_addr |= be32_to_cpu(fh[3]); |
| 255 | return gfs2_get_dentry(sb, &this); |
| 256 | default: |
| 257 | return NULL; |
| 258 | } |
| 259 | } |
| 260 | |
| 261 | static struct dentry *gfs2_fh_to_parent(struct super_block *sb, struct fid *fid, |
| 262 | int fh_len, int fh_type) |
| 263 | { |
| 264 | struct gfs2_inum_host parent; |
| 265 | __be32 *fh = (__force __be32 *)fid->raw; |
| 266 | |
| 267 | switch (fh_type) { |
| 268 | case GFS2_LARGE_FH_SIZE: |
| 269 | case GFS2_OLD_FH_SIZE: |
| 270 | parent.no_formal_ino = ((u64)be32_to_cpu(fh[4])) << 32; |
| 271 | parent.no_formal_ino |= be32_to_cpu(fh[5]); |
| 272 | parent.no_addr = ((u64)be32_to_cpu(fh[6])) << 32; |
| 273 | parent.no_addr |= be32_to_cpu(fh[7]); |
| 274 | return gfs2_get_dentry(sb, &parent); |
| 275 | default: |
| 276 | return NULL; |
| 277 | } |
| 278 | } |
| 279 | |
Christoph Hellwig | 3965516 | 2007-10-21 16:42:17 -0700 | [diff] [blame] | 280 | const struct export_operations gfs2_export_ops = { |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 281 | .encode_fh = gfs2_encode_fh, |
Christoph Hellwig | 34c0d15 | 2007-10-21 16:42:14 -0700 | [diff] [blame] | 282 | .fh_to_dentry = gfs2_fh_to_dentry, |
| 283 | .fh_to_parent = gfs2_fh_to_parent, |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 284 | .get_name = gfs2_get_name, |
| 285 | .get_parent = gfs2_get_parent, |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 286 | }; |
| 287 | |