Commit | Line | Data |
---|---|---|
b3b94faa DT |
1 | /* |
2 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | |
3a8a9a10 | 3 | * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. |
b3b94faa DT |
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 | |
e9fc2aa0 | 7 | * of the GNU General Public License version 2. |
b3b94faa DT |
8 | */ |
9 | ||
b3b94faa DT |
10 | #include <linux/spinlock.h> |
11 | #include <linux/completion.h> | |
12 | #include <linux/buffer_head.h> | |
a5694255 | 13 | #include <linux/exportfs.h> |
5c676f6d | 14 | #include <linux/gfs2_ondisk.h> |
71b86f56 | 15 | #include <linux/crc32.h> |
b3b94faa DT |
16 | |
17 | #include "gfs2.h" | |
5c676f6d | 18 | #include "incore.h" |
b3b94faa DT |
19 | #include "dir.h" |
20 | #include "glock.h" | |
21 | #include "glops.h" | |
22 | #include "inode.h" | |
b2760583 | 23 | #include "super.h" |
b3b94faa | 24 | #include "rgrp.h" |
c752666c | 25 | #include "util.h" |
b3b94faa | 26 | |
bb8d8a6f | 27 | #define GFS2_SMALL_FH_SIZE 4 |
35dcc52e | 28 | #define GFS2_LARGE_FH_SIZE 8 |
3ebf4490 | 29 | #define GFS2_OLD_FH_SIZE 10 |
bb8d8a6f | 30 | |
b0b0382b AV |
31 | static int gfs2_encode_fh(struct inode *inode, __u32 *p, int *len, |
32 | struct inode *parent) | |
b3b94faa | 33 | { |
b44b84d7 | 34 | __be32 *fh = (__force __be32 *)p; |
c9fd4307 | 35 | struct super_block *sb = inode->i_sb; |
feaa7bba | 36 | struct gfs2_inode *ip = GFS2_I(inode); |
b3b94faa | 37 | |
b0b0382b | 38 | if (parent && (*len < GFS2_LARGE_FH_SIZE)) { |
5fe0c237 | 39 | *len = GFS2_LARGE_FH_SIZE; |
94e07a75 | 40 | return FILEID_INVALID; |
5fe0c237 AK |
41 | } else if (*len < GFS2_SMALL_FH_SIZE) { |
42 | *len = GFS2_SMALL_FH_SIZE; | |
94e07a75 | 43 | return FILEID_INVALID; |
5fe0c237 | 44 | } |
b3b94faa | 45 | |
dbb7cae2 SW |
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); | |
5acd3967 | 50 | *len = GFS2_SMALL_FH_SIZE; |
b3b94faa | 51 | |
2b0143b5 | 52 | if (!parent || inode == d_inode(sb->s_root)) |
b3b94faa DT |
53 | return *len; |
54 | ||
b0b0382b | 55 | ip = GFS2_I(parent); |
b3b94faa | 56 | |
dbb7cae2 SW |
57 | fh[4] = cpu_to_be32(ip->i_no_formal_ino >> 32); |
58 | fh[5] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF); | |
59 | fh[6] = cpu_to_be32(ip->i_no_addr >> 32); | |
60 | fh[7] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF); | |
5acd3967 | 61 | *len = GFS2_LARGE_FH_SIZE; |
b3b94faa | 62 | |
b3b94faa DT |
63 | return *len; |
64 | } | |
65 | ||
66 | struct get_name_filldir { | |
d81a8ef5 | 67 | struct dir_context ctx; |
629a21e7 | 68 | struct gfs2_inum_host inum; |
b3b94faa DT |
69 | char *name; |
70 | }; | |
71 | ||
ac7576f4 MS |
72 | static int get_name_filldir(struct dir_context *ctx, const char *name, |
73 | int length, loff_t offset, u64 inum, | |
74 | unsigned int type) | |
b3b94faa | 75 | { |
ac7576f4 MS |
76 | struct get_name_filldir *gnfd = |
77 | container_of(ctx, struct get_name_filldir, ctx); | |
b3b94faa | 78 | |
3699e3a4 | 79 | if (inum != gnfd->inum.no_addr) |
b3b94faa DT |
80 | return 0; |
81 | ||
82 | memcpy(gnfd->name, name, length); | |
83 | gnfd->name[length] = 0; | |
84 | ||
85 | return 1; | |
86 | } | |
87 | ||
88 | static int gfs2_get_name(struct dentry *parent, char *name, | |
89 | struct dentry *child) | |
90 | { | |
2b0143b5 DH |
91 | struct inode *dir = d_inode(parent); |
92 | struct inode *inode = d_inode(child); | |
b3b94faa | 93 | struct gfs2_inode *dip, *ip; |
ac6614b7 AV |
94 | struct get_name_filldir gnfd = { |
95 | .ctx.actor = get_name_filldir, | |
96 | .name = name | |
97 | }; | |
b3b94faa | 98 | struct gfs2_holder gh; |
b3b94faa | 99 | int error; |
dfe4d34b | 100 | struct file_ra_state f_ra = { .start = 0 }; |
b3b94faa DT |
101 | |
102 | if (!dir) | |
103 | return -EINVAL; | |
104 | ||
b3b94faa DT |
105 | if (!S_ISDIR(dir->i_mode) || !inode) |
106 | return -EINVAL; | |
107 | ||
feaa7bba SW |
108 | dip = GFS2_I(dir); |
109 | ip = GFS2_I(inode); | |
b3b94faa DT |
110 | |
111 | *name = 0; | |
dbb7cae2 SW |
112 | gnfd.inum.no_addr = ip->i_no_addr; |
113 | gnfd.inum.no_formal_ino = ip->i_no_formal_ino; | |
b3b94faa DT |
114 | |
115 | error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh); | |
116 | if (error) | |
117 | return error; | |
118 | ||
d81a8ef5 | 119 | error = gfs2_dir_read(dir, &gnfd.ctx, &f_ra); |
b3b94faa DT |
120 | |
121 | gfs2_glock_dq_uninit(&gh); | |
122 | ||
123 | if (!error && !*name) | |
124 | error = -ENOENT; | |
125 | ||
126 | return error; | |
127 | } | |
128 | ||
129 | static struct dentry *gfs2_get_parent(struct dentry *child) | |
130 | { | |
2b0143b5 | 131 | return d_obtain_alias(gfs2_lookupi(d_inode(child), &gfs2_qdotdot, 1)); |
b3b94faa DT |
132 | } |
133 | ||
34c0d154 | 134 | static struct dentry *gfs2_get_dentry(struct super_block *sb, |
acf7e244 | 135 | struct gfs2_inum_host *inum) |
b3b94faa | 136 | { |
5c676f6d | 137 | struct gfs2_sbd *sdp = sb->s_fs_info; |
b3b94faa | 138 | struct inode *inode; |
b3b94faa | 139 | |
ff34245d | 140 | inode = gfs2_ilookup(sb, inum->no_addr); |
b3b94faa | 141 | if (inode) { |
dbb7cae2 | 142 | if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) { |
b3b94faa DT |
143 | iput(inode); |
144 | return ERR_PTR(-ESTALE); | |
145 | } | |
146 | goto out_inode; | |
147 | } | |
148 | ||
044b9414 SW |
149 | inode = gfs2_lookup_by_inum(sdp, inum->no_addr, &inum->no_formal_ino, |
150 | GFS2_BLKST_DINODE); | |
151 | if (IS_ERR(inode)) | |
152 | return ERR_CAST(inode); | |
b3b94faa | 153 | |
feaa7bba | 154 | out_inode: |
41ced6dc | 155 | return d_obtain_alias(inode); |
b3b94faa DT |
156 | } |
157 | ||
34c0d154 CH |
158 | static struct dentry *gfs2_fh_to_dentry(struct super_block *sb, struct fid *fid, |
159 | int fh_len, int fh_type) | |
160 | { | |
161 | struct gfs2_inum_host this; | |
162 | __be32 *fh = (__force __be32 *)fid->raw; | |
163 | ||
164 | switch (fh_type) { | |
165 | case GFS2_SMALL_FH_SIZE: | |
166 | case GFS2_LARGE_FH_SIZE: | |
167 | case GFS2_OLD_FH_SIZE: | |
35c2a7f4 HD |
168 | if (fh_len < GFS2_SMALL_FH_SIZE) |
169 | return NULL; | |
34c0d154 CH |
170 | this.no_formal_ino = ((u64)be32_to_cpu(fh[0])) << 32; |
171 | this.no_formal_ino |= be32_to_cpu(fh[1]); | |
172 | this.no_addr = ((u64)be32_to_cpu(fh[2])) << 32; | |
173 | this.no_addr |= be32_to_cpu(fh[3]); | |
174 | return gfs2_get_dentry(sb, &this); | |
175 | default: | |
176 | return NULL; | |
177 | } | |
178 | } | |
179 | ||
180 | static struct dentry *gfs2_fh_to_parent(struct super_block *sb, struct fid *fid, | |
181 | int fh_len, int fh_type) | |
182 | { | |
183 | struct gfs2_inum_host parent; | |
184 | __be32 *fh = (__force __be32 *)fid->raw; | |
185 | ||
186 | switch (fh_type) { | |
187 | case GFS2_LARGE_FH_SIZE: | |
188 | case GFS2_OLD_FH_SIZE: | |
35c2a7f4 HD |
189 | if (fh_len < GFS2_LARGE_FH_SIZE) |
190 | return NULL; | |
34c0d154 CH |
191 | parent.no_formal_ino = ((u64)be32_to_cpu(fh[4])) << 32; |
192 | parent.no_formal_ino |= be32_to_cpu(fh[5]); | |
193 | parent.no_addr = ((u64)be32_to_cpu(fh[6])) << 32; | |
194 | parent.no_addr |= be32_to_cpu(fh[7]); | |
195 | return gfs2_get_dentry(sb, &parent); | |
196 | default: | |
197 | return NULL; | |
198 | } | |
199 | } | |
200 | ||
39655164 | 201 | const struct export_operations gfs2_export_ops = { |
b3b94faa | 202 | .encode_fh = gfs2_encode_fh, |
34c0d154 CH |
203 | .fh_to_dentry = gfs2_fh_to_dentry, |
204 | .fh_to_parent = gfs2_fh_to_parent, | |
b3b94faa DT |
205 | .get_name = gfs2_get_name, |
206 | .get_parent = gfs2_get_parent, | |
b3b94faa DT |
207 | }; |
208 |