1/*
2 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
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 version 2.
8 */
9
10#include <linux/spinlock.h>
11#include <linux/completion.h>
12#include <linux/buffer_head.h>
13#include <linux/exportfs.h>
14#include <linux/gfs2_ondisk.h>
15#include <linux/crc32.h>
16
17#include "gfs2.h"
18#include "incore.h"
19#include "dir.h"
20#include "glock.h"
21#include "glops.h"
22#include "inode.h"
23#include "super.h"
24#include "rgrp.h"
25#include "util.h"
26
27#define GFS2_SMALL_FH_SIZE 4
28#define GFS2_LARGE_FH_SIZE 8
29#define GFS2_OLD_FH_SIZE 10
30
31static int gfs2_encode_fh(struct inode *inode, __u32 *p, int *len,
32			  struct inode *parent)
33{
34	__be32 *fh = (__force __be32 *)p;
35	struct super_block *sb = inode->i_sb;
36	struct gfs2_inode *ip = GFS2_I(inode);
37
38	if (parent && (*len < GFS2_LARGE_FH_SIZE)) {
39		*len = GFS2_LARGE_FH_SIZE;
40		return FILEID_INVALID;
41	} else if (*len < GFS2_SMALL_FH_SIZE) {
42		*len = GFS2_SMALL_FH_SIZE;
43		return FILEID_INVALID;
44	}
45
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);
50	*len = GFS2_SMALL_FH_SIZE;
51
52	if (!parent || inode == d_inode(sb->s_root))
53		return *len;
54
55	ip = GFS2_I(parent);
56
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);
61	*len = GFS2_LARGE_FH_SIZE;
62
63	return *len;
64}
65
66struct get_name_filldir {
67	struct dir_context ctx;
68	struct gfs2_inum_host inum;
69	char *name;
70};
71
72static int get_name_filldir(struct dir_context *ctx, const char *name,
73			    int length, loff_t offset, u64 inum,
74			    unsigned int type)
75{
76	struct get_name_filldir *gnfd =
77		container_of(ctx, struct get_name_filldir, ctx);
78
79	if (inum != gnfd->inum.no_addr)
80		return 0;
81
82	memcpy(gnfd->name, name, length);
83	gnfd->name[length] = 0;
84
85	return 1;
86}
87
88static int gfs2_get_name(struct dentry *parent, char *name,
89			 struct dentry *child)
90{
91	struct inode *dir = d_inode(parent);
92	struct inode *inode = d_inode(child);
93	struct gfs2_inode *dip, *ip;
94	struct get_name_filldir gnfd = {
95		.ctx.actor = get_name_filldir,
96		.name = name
97	};
98	struct gfs2_holder gh;
99	int error;
100	struct file_ra_state f_ra = { .start = 0 };
101
102	if (!dir)
103		return -EINVAL;
104
105	if (!S_ISDIR(dir->i_mode) || !inode)
106		return -EINVAL;
107
108	dip = GFS2_I(dir);
109	ip = GFS2_I(inode);
110
111	*name = 0;
112	gnfd.inum.no_addr = ip->i_no_addr;
113	gnfd.inum.no_formal_ino = ip->i_no_formal_ino;
114
115	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh);
116	if (error)
117		return error;
118
119	error = gfs2_dir_read(dir, &gnfd.ctx, &f_ra);
120
121	gfs2_glock_dq_uninit(&gh);
122
123	if (!error && !*name)
124		error = -ENOENT;
125
126	return error;
127}
128
129static struct dentry *gfs2_get_parent(struct dentry *child)
130{
131	return d_obtain_alias(gfs2_lookupi(d_inode(child), &gfs2_qdotdot, 1));
132}
133
134static struct dentry *gfs2_get_dentry(struct super_block *sb,
135				      struct gfs2_inum_host *inum)
136{
137	struct gfs2_sbd *sdp = sb->s_fs_info;
138	struct inode *inode;
139
140	inode = gfs2_ilookup(sb, inum->no_addr, 0);
141	if (inode) {
142		if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) {
143			iput(inode);
144			return ERR_PTR(-ESTALE);
145		}
146		goto out_inode;
147	}
148
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);
153
154out_inode:
155	return d_obtain_alias(inode);
156}
157
158static 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:
168		if (fh_len < GFS2_SMALL_FH_SIZE)
169			return NULL;
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
180static 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:
189		if (fh_len < GFS2_LARGE_FH_SIZE)
190			return NULL;
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
201const struct export_operations gfs2_export_ops = {
202	.encode_fh = gfs2_encode_fh,
203	.fh_to_dentry = gfs2_fh_to_dentry,
204	.fh_to_parent = gfs2_fh_to_parent,
205	.get_name = gfs2_get_name,
206	.get_parent = gfs2_get_parent,
207};
208
209