Commit | Line | Data |
---|---|---|
66c7e1d3 DH |
1 | /* dir.c: AFS dynamic root handling |
2 | * | |
3 | * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved. | |
4 | * Written by David Howells (dhowells@redhat.com) | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public Licence | |
8 | * as published by the Free Software Foundation; either version | |
9 | * 2 of the Licence, or (at your option) any later version. | |
10 | */ | |
11 | ||
12 | #include <linux/fs.h> | |
13 | #include <linux/namei.h> | |
14 | #include <linux/dns_resolver.h> | |
15 | #include "internal.h" | |
16 | ||
17 | const struct file_operations afs_dynroot_file_operations = { | |
18 | .open = dcache_dir_open, | |
19 | .release = dcache_dir_close, | |
20 | .iterate_shared = dcache_readdir, | |
21 | .llseek = dcache_dir_lseek, | |
22 | }; | |
23 | ||
24 | /* | |
25 | * Probe to see if a cell may exist. This prevents positive dentries from | |
26 | * being created unnecessarily. | |
27 | */ | |
28 | static int afs_probe_cell_name(struct dentry *dentry) | |
29 | { | |
30 | struct afs_cell *cell; | |
31 | const char *name = dentry->d_name.name; | |
32 | size_t len = dentry->d_name.len; | |
33 | int ret; | |
34 | ||
35 | /* Names prefixed with a dot are R/W mounts. */ | |
36 | if (name[0] == '.') { | |
37 | if (len == 1) | |
38 | return -EINVAL; | |
39 | name++; | |
40 | len--; | |
41 | } | |
42 | ||
43 | cell = afs_lookup_cell_rcu(afs_d2net(dentry), name, len); | |
44 | if (!IS_ERR(cell)) { | |
45 | afs_put_cell(afs_d2net(dentry), cell); | |
46 | return 0; | |
47 | } | |
48 | ||
c88d5a7f | 49 | ret = dns_query("afsdb", name, len, "", NULL, NULL); |
66c7e1d3 DH |
50 | if (ret == -ENODATA) |
51 | ret = -EDESTADDRREQ; | |
52 | return ret; | |
53 | } | |
54 | ||
55 | /* | |
56 | * Try to auto mount the mountpoint with pseudo directory, if the autocell | |
57 | * operation is setted. | |
58 | */ | |
59 | struct inode *afs_try_auto_mntpt(struct dentry *dentry, struct inode *dir) | |
60 | { | |
61 | struct afs_vnode *vnode = AFS_FS_I(dir); | |
62 | struct inode *inode; | |
63 | int ret = -ENOENT; | |
64 | ||
65 | _enter("%p{%pd}, {%x:%u}", | |
66 | dentry, dentry, vnode->fid.vid, vnode->fid.vnode); | |
67 | ||
68 | if (!test_bit(AFS_VNODE_AUTOCELL, &vnode->flags)) | |
69 | goto out; | |
70 | ||
71 | ret = afs_probe_cell_name(dentry); | |
72 | if (ret < 0) | |
73 | goto out; | |
74 | ||
75 | inode = afs_iget_pseudo_dir(dir->i_sb, false); | |
76 | if (IS_ERR(inode)) { | |
77 | ret = PTR_ERR(inode); | |
78 | goto out; | |
79 | } | |
80 | ||
81 | _leave("= %p", inode); | |
82 | return inode; | |
83 | ||
84 | out: | |
85 | _leave("= %d", ret); | |
86 | return ERR_PTR(ret); | |
87 | } | |
88 | ||
89 | /* | |
90 | * Look up @cell in a dynroot directory. This is a substitution for the | |
91 | * local cell name for the net namespace. | |
92 | */ | |
93 | static struct dentry *afs_lookup_atcell(struct dentry *dentry) | |
94 | { | |
95 | struct afs_cell *cell; | |
96 | struct afs_net *net = afs_d2net(dentry); | |
97 | struct dentry *ret; | |
98 | unsigned int seq = 0; | |
99 | char *name; | |
100 | int len; | |
101 | ||
102 | if (!net->ws_cell) | |
103 | return ERR_PTR(-ENOENT); | |
104 | ||
105 | ret = ERR_PTR(-ENOMEM); | |
106 | name = kmalloc(AFS_MAXCELLNAME + 1, GFP_KERNEL); | |
107 | if (!name) | |
108 | goto out_p; | |
109 | ||
110 | rcu_read_lock(); | |
111 | do { | |
112 | read_seqbegin_or_lock(&net->cells_lock, &seq); | |
113 | cell = rcu_dereference_raw(net->ws_cell); | |
114 | if (cell) { | |
115 | len = cell->name_len; | |
116 | memcpy(name, cell->name, len + 1); | |
117 | } | |
118 | } while (need_seqretry(&net->cells_lock, seq)); | |
119 | done_seqretry(&net->cells_lock, seq); | |
120 | rcu_read_unlock(); | |
121 | ||
122 | ret = ERR_PTR(-ENOENT); | |
123 | if (!cell) | |
124 | goto out_n; | |
125 | ||
126 | ret = lookup_one_len(name, dentry->d_parent, len); | |
127 | ||
128 | /* We don't want to d_add() the @cell dentry here as we don't want to | |
129 | * the cached dentry to hide changes to the local cell name. | |
130 | */ | |
131 | ||
132 | out_n: | |
133 | kfree(name); | |
134 | out_p: | |
135 | return ret; | |
136 | } | |
137 | ||
138 | /* | |
139 | * Look up an entry in a dynroot directory. | |
140 | */ | |
141 | static struct dentry *afs_dynroot_lookup(struct inode *dir, struct dentry *dentry, | |
142 | unsigned int flags) | |
143 | { | |
144 | struct afs_vnode *vnode; | |
145 | struct inode *inode; | |
146 | int ret; | |
147 | ||
148 | vnode = AFS_FS_I(dir); | |
149 | ||
150 | _enter("%pd", dentry); | |
151 | ||
152 | ASSERTCMP(d_inode(dentry), ==, NULL); | |
153 | ||
154 | if (dentry->d_name.len >= AFSNAMEMAX) { | |
155 | _leave(" = -ENAMETOOLONG"); | |
156 | return ERR_PTR(-ENAMETOOLONG); | |
157 | } | |
158 | ||
159 | if (dentry->d_name.len == 5 && | |
160 | memcmp(dentry->d_name.name, "@cell", 5) == 0) | |
161 | return afs_lookup_atcell(dentry); | |
162 | ||
163 | inode = afs_try_auto_mntpt(dentry, dir); | |
164 | if (IS_ERR(inode)) { | |
165 | ret = PTR_ERR(inode); | |
166 | if (ret == -ENOENT) { | |
167 | d_add(dentry, NULL); | |
168 | _leave(" = NULL [negative]"); | |
169 | return NULL; | |
170 | } | |
171 | _leave(" = %d [do]", ret); | |
172 | return ERR_PTR(ret); | |
173 | } | |
174 | ||
175 | d_add(dentry, inode); | |
176 | _leave(" = 0 { ino=%lu v=%u }", | |
177 | d_inode(dentry)->i_ino, d_inode(dentry)->i_generation); | |
178 | return NULL; | |
179 | } | |
180 | ||
181 | const struct inode_operations afs_dynroot_inode_operations = { | |
182 | .lookup = afs_dynroot_lookup, | |
183 | }; | |
184 | ||
185 | /* | |
186 | * Dirs in the dynamic root don't need revalidation. | |
187 | */ | |
188 | static int afs_dynroot_d_revalidate(struct dentry *dentry, unsigned int flags) | |
189 | { | |
190 | return 1; | |
191 | } | |
192 | ||
193 | /* | |
194 | * Allow the VFS to enquire as to whether a dentry should be unhashed (mustn't | |
195 | * sleep) | |
196 | * - called from dput() when d_count is going to 0. | |
197 | * - return 1 to request dentry be unhashed, 0 otherwise | |
198 | */ | |
199 | static int afs_dynroot_d_delete(const struct dentry *dentry) | |
200 | { | |
201 | return d_really_is_positive(dentry); | |
202 | } | |
203 | ||
204 | const struct dentry_operations afs_dynroot_dentry_operations = { | |
205 | .d_revalidate = afs_dynroot_d_revalidate, | |
206 | .d_delete = afs_dynroot_d_delete, | |
207 | .d_release = afs_d_release, | |
208 | .d_automount = afs_d_automount, | |
209 | }; |