blob: e10e17788f06073b2cd80204bf09343918654111 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* dir.c: AFS filesystem directory handling
2 *
3 * Copyright (C) 2002 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 License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/fs.h>
Nick Piggin34286d62011-01-07 17:49:57 +110016#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/pagemap.h>
David Howells00d3b7a2007-04-26 15:57:07 -070018#include <linux/ctype.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040019#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "internal.h"
21
David Howells260a9802007-04-26 15:59:35 -070022static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
Al Viro00cd8dd2012-06-10 17:13:09 -040023 unsigned int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -070024static int afs_dir_open(struct inode *inode, struct file *file);
Al Viro1bbae9f2013-05-22 16:31:14 -040025static int afs_readdir(struct file *file, struct dir_context *ctx);
Al Viro0b728e12012-06-10 16:03:43 -040026static int afs_d_revalidate(struct dentry *dentry, unsigned int flags);
Nick Pigginfe15ce42011-01-07 17:49:23 +110027static int afs_d_delete(const struct dentry *dentry);
David Howells260a9802007-04-26 15:59:35 -070028static void afs_d_release(struct dentry *dentry);
Miklos Szerediac7576f2014-10-30 17:37:34 +010029static int afs_lookup_filldir(struct dir_context *ctx, const char *name, int nlen,
David Howellsafefdbb2006-10-03 01:13:46 -070030 loff_t fpos, u64 ino, unsigned dtype);
Al Viro4acdaf22011-07-26 01:42:34 -040031static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
Al Viroebfc3b42012-06-10 18:05:36 -040032 bool excl);
Al Viro18bb1db2011-07-26 01:41:39 -040033static int afs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode);
David Howells260a9802007-04-26 15:59:35 -070034static int afs_rmdir(struct inode *dir, struct dentry *dentry);
35static int afs_unlink(struct inode *dir, struct dentry *dentry);
36static int afs_link(struct dentry *from, struct inode *dir,
37 struct dentry *dentry);
38static int afs_symlink(struct inode *dir, struct dentry *dentry,
39 const char *content);
40static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
41 struct inode *new_dir, struct dentry *new_dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080043const struct file_operations afs_dir_file_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 .open = afs_dir_open,
David Howells00d3b7a2007-04-26 15:57:07 -070045 .release = afs_release,
Al Viro1bbae9f2013-05-22 16:31:14 -040046 .iterate = afs_readdir,
David Howellse8d6c552007-07-15 23:40:12 -070047 .lock = afs_lock,
Christoph Hellwig3222a3e2008-09-03 21:53:01 +020048 .llseek = generic_file_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -070049};
50
Arjan van de Ven754661f2007-02-12 00:55:38 -080051const struct inode_operations afs_dir_inode_operations = {
David Howells260a9802007-04-26 15:59:35 -070052 .create = afs_create,
53 .lookup = afs_lookup,
54 .link = afs_link,
55 .unlink = afs_unlink,
56 .symlink = afs_symlink,
57 .mkdir = afs_mkdir,
58 .rmdir = afs_rmdir,
59 .rename = afs_rename,
David Howells00d3b7a2007-04-26 15:57:07 -070060 .permission = afs_permission,
David Howells416351f2007-05-09 02:33:45 -070061 .getattr = afs_getattr,
David Howells31143d52007-05-09 02:33:46 -070062 .setattr = afs_setattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -070063};
64
Al Virod61dcce2011-01-12 20:04:20 -050065const struct dentry_operations afs_fs_dentry_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 .d_revalidate = afs_d_revalidate,
67 .d_delete = afs_d_delete,
David Howells260a9802007-04-26 15:59:35 -070068 .d_release = afs_d_release,
David Howellsd18610b2011-01-14 19:04:05 +000069 .d_automount = afs_d_automount,
Linus Torvalds1da177e2005-04-16 15:20:36 -070070};
71
72#define AFS_DIR_HASHTBL_SIZE 128
73#define AFS_DIR_DIRENT_SIZE 32
74#define AFS_DIRENT_PER_BLOCK 64
75
76union afs_dirent {
77 struct {
78 uint8_t valid;
79 uint8_t unused[1];
80 __be16 hash_next;
81 __be32 vnode;
82 __be32 unique;
83 uint8_t name[16];
84 uint8_t overflow[4]; /* if any char of the name (inc
85 * NUL) reaches here, consume
86 * the next dirent too */
87 } u;
88 uint8_t extended_name[32];
89};
90
91/* AFS directory page header (one at the beginning of every 2048-byte chunk) */
92struct afs_dir_pagehdr {
93 __be16 npages;
94 __be16 magic;
95#define AFS_DIR_MAGIC htons(1234)
96 uint8_t nentries;
97 uint8_t bitmap[8];
98 uint8_t pad[19];
99};
100
101/* directory block layout */
102union afs_dir_block {
103
104 struct afs_dir_pagehdr pagehdr;
105
106 struct {
107 struct afs_dir_pagehdr pagehdr;
108 uint8_t alloc_ctrs[128];
109 /* dir hash table */
110 uint16_t hashtable[AFS_DIR_HASHTBL_SIZE];
111 } hdr;
112
113 union afs_dirent dirents[AFS_DIRENT_PER_BLOCK];
114};
115
116/* layout on a linux VM page */
117struct afs_dir_page {
118 union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)];
119};
120
David Howells260a9802007-04-26 15:59:35 -0700121struct afs_lookup_cookie {
Al Viro1bbae9f2013-05-22 16:31:14 -0400122 struct dir_context ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 struct afs_fid fid;
Al Viro1bbae9f2013-05-22 16:31:14 -0400124 struct qstr name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 int found;
126};
127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128/*
129 * check that a directory page is valid
130 */
131static inline void afs_dir_check_page(struct inode *dir, struct page *page)
132{
133 struct afs_dir_page *dbuf;
134 loff_t latter;
135 int tmp, qty;
136
137#if 0
138 /* check the page count */
139 qty = desc.size / sizeof(dbuf->blocks[0]);
140 if (qty == 0)
141 goto error;
142
David Howells08e0e7c2007-04-26 15:55:03 -0700143 if (page->index == 0 && qty != ntohs(dbuf->blocks[0].pagehdr.npages)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 printk("kAFS: %s(%lu): wrong number of dir blocks %d!=%hu\n",
Harvey Harrison530b6412008-04-30 00:55:09 -0700145 __func__, dir->i_ino, qty,
David Howells08e0e7c2007-04-26 15:55:03 -0700146 ntohs(dbuf->blocks[0].pagehdr.npages));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 goto error;
148 }
149#endif
150
151 /* determine how many magic numbers there should be in this page */
Andrew Morton54b21a72006-01-08 01:03:05 -0800152 latter = dir->i_size - page_offset(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 if (latter >= PAGE_SIZE)
154 qty = PAGE_SIZE;
155 else
156 qty = latter;
157 qty /= sizeof(union afs_dir_block);
158
159 /* check them */
160 dbuf = page_address(page);
161 for (tmp = 0; tmp < qty; tmp++) {
162 if (dbuf->blocks[tmp].pagehdr.magic != AFS_DIR_MAGIC) {
163 printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n",
Harvey Harrison530b6412008-04-30 00:55:09 -0700164 __func__, dir->i_ino, tmp, qty,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 ntohs(dbuf->blocks[tmp].pagehdr.magic));
166 goto error;
167 }
168 }
169
170 SetPageChecked(page);
171 return;
172
David Howellsec268152007-04-26 15:49:28 -0700173error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 SetPageChecked(page);
175 SetPageError(page);
David Howellsec268152007-04-26 15:49:28 -0700176}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178/*
179 * discard a page cached in the pagecache
180 */
181static inline void afs_dir_put_page(struct page *page)
182{
183 kunmap(page);
184 page_cache_release(page);
David Howellsec268152007-04-26 15:49:28 -0700185}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187/*
188 * get a page into the pagecache
189 */
David Howells00d3b7a2007-04-26 15:57:07 -0700190static struct page *afs_dir_get_page(struct inode *dir, unsigned long index,
191 struct key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192{
193 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 _enter("{%lu},%lu", dir->i_ino, index);
195
Al Virof6d335c2010-05-21 15:27:09 +0100196 page = read_cache_page(dir->i_mapping, index, afs_page_filler, key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (!IS_ERR(page)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 kmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 if (!PageChecked(page))
200 afs_dir_check_page(dir, page);
201 if (PageError(page))
202 goto fail;
203 }
204 return page;
205
David Howellsec268152007-04-26 15:49:28 -0700206fail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 afs_dir_put_page(page);
David Howells08e0e7c2007-04-26 15:55:03 -0700208 _leave(" = -EIO");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 return ERR_PTR(-EIO);
David Howellsec268152007-04-26 15:49:28 -0700210}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212/*
213 * open an AFS directory file
214 */
215static int afs_dir_open(struct inode *inode, struct file *file)
216{
217 _enter("{%lu}", inode->i_ino);
218
Alexey Dobriyan2ecd05a2006-10-11 01:22:05 -0700219 BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048);
220 BUILD_BUG_ON(sizeof(union afs_dirent) != 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
David Howells08e0e7c2007-04-26 15:55:03 -0700222 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(inode)->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 return -ENOENT;
224
David Howells00d3b7a2007-04-26 15:57:07 -0700225 return afs_open(inode, file);
David Howellsec268152007-04-26 15:49:28 -0700226}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228/*
229 * deal with one block in an AFS directory
230 */
Al Viro1bbae9f2013-05-22 16:31:14 -0400231static int afs_dir_iterate_block(struct dir_context *ctx,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 union afs_dir_block *block,
Al Viro1bbae9f2013-05-22 16:31:14 -0400233 unsigned blkoff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
235 union afs_dirent *dire;
236 unsigned offset, next, curr;
237 size_t nlen;
Al Viro1bbae9f2013-05-22 16:31:14 -0400238 int tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
Al Viro1bbae9f2013-05-22 16:31:14 -0400240 _enter("%u,%x,%p,,",(unsigned)ctx->pos,blkoff,block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
Al Viro1bbae9f2013-05-22 16:31:14 -0400242 curr = (ctx->pos - blkoff) / sizeof(union afs_dirent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 /* walk through the block, an entry at a time */
245 for (offset = AFS_DIRENT_PER_BLOCK - block->pagehdr.nentries;
246 offset < AFS_DIRENT_PER_BLOCK;
247 offset = next
248 ) {
249 next = offset + 1;
250
251 /* skip entries marked unused in the bitmap */
252 if (!(block->pagehdr.bitmap[offset / 8] &
253 (1 << (offset % 8)))) {
David Howells08e0e7c2007-04-26 15:55:03 -0700254 _debug("ENT[%Zu.%u]: unused",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 blkoff / sizeof(union afs_dir_block), offset);
256 if (offset >= curr)
Al Viro1bbae9f2013-05-22 16:31:14 -0400257 ctx->pos = blkoff +
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 next * sizeof(union afs_dirent);
259 continue;
260 }
261
262 /* got a valid entry */
263 dire = &block->dirents[offset];
264 nlen = strnlen(dire->u.name,
265 sizeof(*block) -
266 offset * sizeof(union afs_dirent));
267
David Howells08e0e7c2007-04-26 15:55:03 -0700268 _debug("ENT[%Zu.%u]: %s %Zu \"%s\"",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 blkoff / sizeof(union afs_dir_block), offset,
270 (offset < curr ? "skip" : "fill"),
271 nlen, dire->u.name);
272
273 /* work out where the next possible entry is */
274 for (tmp = nlen; tmp > 15; tmp -= sizeof(union afs_dirent)) {
275 if (next >= AFS_DIRENT_PER_BLOCK) {
276 _debug("ENT[%Zu.%u]:"
277 " %u travelled beyond end dir block"
David Howells08e0e7c2007-04-26 15:55:03 -0700278 " (len %u/%Zu)",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 blkoff / sizeof(union afs_dir_block),
280 offset, next, tmp, nlen);
281 return -EIO;
282 }
283 if (!(block->pagehdr.bitmap[next / 8] &
284 (1 << (next % 8)))) {
285 _debug("ENT[%Zu.%u]:"
David Howells08e0e7c2007-04-26 15:55:03 -0700286 " %u unmarked extension (len %u/%Zu)",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 blkoff / sizeof(union afs_dir_block),
288 offset, next, tmp, nlen);
289 return -EIO;
290 }
291
David Howells08e0e7c2007-04-26 15:55:03 -0700292 _debug("ENT[%Zu.%u]: ext %u/%Zu",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 blkoff / sizeof(union afs_dir_block),
294 next, tmp, nlen);
295 next++;
296 }
297
298 /* skip if starts before the current position */
299 if (offset < curr)
300 continue;
301
302 /* found the next entry */
Al Viro1bbae9f2013-05-22 16:31:14 -0400303 if (!dir_emit(ctx, dire->u.name, nlen,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 ntohl(dire->u.vnode),
Al Viro1bbae9f2013-05-22 16:31:14 -0400305 ctx->actor == afs_lookup_filldir ?
306 ntohl(dire->u.unique) : DT_UNKNOWN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 _leave(" = 0 [full]");
308 return 0;
309 }
310
Al Viro1bbae9f2013-05-22 16:31:14 -0400311 ctx->pos = blkoff + next * sizeof(union afs_dirent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 }
313
314 _leave(" = 1 [more]");
315 return 1;
David Howellsec268152007-04-26 15:49:28 -0700316}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318/*
David Howells08e0e7c2007-04-26 15:55:03 -0700319 * iterate through the data blob that lists the contents of an AFS directory
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 */
Al Viro1bbae9f2013-05-22 16:31:14 -0400321static int afs_dir_iterate(struct inode *dir, struct dir_context *ctx,
322 struct key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
David Howells08e0e7c2007-04-26 15:55:03 -0700324 union afs_dir_block *dblock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 struct afs_dir_page *dbuf;
326 struct page *page;
327 unsigned blkoff, limit;
328 int ret;
329
Al Viro1bbae9f2013-05-22 16:31:14 -0400330 _enter("{%lu},%u,,", dir->i_ino, (unsigned)ctx->pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
David Howells08e0e7c2007-04-26 15:55:03 -0700332 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dir)->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 _leave(" = -ESTALE");
334 return -ESTALE;
335 }
336
337 /* round the file position up to the next entry boundary */
Al Viro1bbae9f2013-05-22 16:31:14 -0400338 ctx->pos += sizeof(union afs_dirent) - 1;
339 ctx->pos &= ~(sizeof(union afs_dirent) - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
341 /* walk through the blocks in sequence */
342 ret = 0;
Al Viro1bbae9f2013-05-22 16:31:14 -0400343 while (ctx->pos < dir->i_size) {
344 blkoff = ctx->pos & ~(sizeof(union afs_dir_block) - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
346 /* fetch the appropriate page from the directory */
David Howells00d3b7a2007-04-26 15:57:07 -0700347 page = afs_dir_get_page(dir, blkoff / PAGE_SIZE, key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 if (IS_ERR(page)) {
349 ret = PTR_ERR(page);
350 break;
351 }
352
353 limit = blkoff & ~(PAGE_SIZE - 1);
354
355 dbuf = page_address(page);
356
357 /* deal with the individual blocks stashed on this page */
358 do {
359 dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) /
360 sizeof(union afs_dir_block)];
Al Viro1bbae9f2013-05-22 16:31:14 -0400361 ret = afs_dir_iterate_block(ctx, dblock, blkoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (ret != 1) {
363 afs_dir_put_page(page);
364 goto out;
365 }
366
367 blkoff += sizeof(union afs_dir_block);
368
Al Viro1bbae9f2013-05-22 16:31:14 -0400369 } while (ctx->pos < dir->i_size && blkoff < limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
371 afs_dir_put_page(page);
372 ret = 0;
373 }
374
David Howellsec268152007-04-26 15:49:28 -0700375out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 _leave(" = %d", ret);
377 return ret;
David Howellsec268152007-04-26 15:49:28 -0700378}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380/*
381 * read an AFS directory
382 */
Al Viro1bbae9f2013-05-22 16:31:14 -0400383static int afs_readdir(struct file *file, struct dir_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
Al Viro1bbae9f2013-05-22 16:31:14 -0400385 return afs_dir_iterate(file_inode(file),
386 ctx, file->private_data);
David Howellsec268152007-04-26 15:49:28 -0700387}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389/*
390 * search the directory for a name
391 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
392 * uniquifier through dtype
393 */
Miklos Szerediac7576f2014-10-30 17:37:34 +0100394static int afs_lookup_filldir(struct dir_context *ctx, const char *name,
395 int nlen, loff_t fpos, u64 ino, unsigned dtype)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396{
Miklos Szerediac7576f2014-10-30 17:37:34 +0100397 struct afs_lookup_cookie *cookie =
398 container_of(ctx, struct afs_lookup_cookie, ctx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Al Viro1bbae9f2013-05-22 16:31:14 -0400400 _enter("{%s,%u},%s,%u,,%llu,%u",
401 cookie->name.name, cookie->name.len, name, nlen,
David S. Millerba3e0e12007-04-26 16:06:22 -0700402 (unsigned long long) ino, dtype);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
David Howells08e0e7c2007-04-26 15:55:03 -0700404 /* insanity checks first */
405 BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048);
406 BUILD_BUG_ON(sizeof(union afs_dirent) != 32);
407
Al Viro1bbae9f2013-05-22 16:31:14 -0400408 if (cookie->name.len != nlen ||
409 memcmp(cookie->name.name, name, nlen) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 _leave(" = 0 [no]");
411 return 0;
412 }
413
414 cookie->fid.vnode = ino;
415 cookie->fid.unique = dtype;
416 cookie->found = 1;
417
418 _leave(" = -1 [found]");
419 return -1;
David Howellsec268152007-04-26 15:49:28 -0700420}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422/*
David Howells08e0e7c2007-04-26 15:55:03 -0700423 * do a lookup in a directory
David Howells260a9802007-04-26 15:59:35 -0700424 * - just returns the FID the dentry name maps to if found
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 */
David Howells08e0e7c2007-04-26 15:55:03 -0700426static int afs_do_lookup(struct inode *dir, struct dentry *dentry,
David Howells00d3b7a2007-04-26 15:57:07 -0700427 struct afs_fid *fid, struct key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428{
Al Viro1bbae9f2013-05-22 16:31:14 -0400429 struct afs_super_info *as = dir->i_sb->s_fs_info;
430 struct afs_lookup_cookie cookie = {
431 .ctx.actor = afs_lookup_filldir,
432 .name = dentry->d_name,
433 .fid.vid = as->volume->vid
434 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 int ret;
436
Al Viroa4555892014-10-21 20:11:25 -0400437 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 /* search the directory */
Al Viro1bbae9f2013-05-22 16:31:14 -0400440 ret = afs_dir_iterate(dir, &cookie.ctx, key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 if (ret < 0) {
David Howells08e0e7c2007-04-26 15:55:03 -0700442 _leave(" = %d [iter]", ret);
443 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
445
446 ret = -ENOENT;
447 if (!cookie.found) {
David Howells08e0e7c2007-04-26 15:55:03 -0700448 _leave(" = -ENOENT [not found]");
449 return -ENOENT;
450 }
451
452 *fid = cookie.fid;
453 _leave(" = 0 { vn=%u u=%u }", fid->vnode, fid->unique);
454 return 0;
455}
456
457/*
wangleibec5eb62010-08-11 09:38:04 +0100458 * Try to auto mount the mountpoint with pseudo directory, if the autocell
459 * operation is setted.
460 */
461static struct inode *afs_try_auto_mntpt(
462 int ret, struct dentry *dentry, struct inode *dir, struct key *key,
463 struct afs_fid *fid)
464{
465 const char *devname = dentry->d_name.name;
466 struct afs_vnode *vnode = AFS_FS_I(dir);
467 struct inode *inode;
468
Al Viroa4555892014-10-21 20:11:25 -0400469 _enter("%d, %p{%pd}, {%x:%u}, %p",
470 ret, dentry, dentry, vnode->fid.vid, vnode->fid.vnode, key);
wangleibec5eb62010-08-11 09:38:04 +0100471
472 if (ret != -ENOENT ||
473 !test_bit(AFS_VNODE_AUTOCELL, &vnode->flags))
474 goto out;
475
476 inode = afs_iget_autocell(dir, devname, strlen(devname), key);
477 if (IS_ERR(inode)) {
478 ret = PTR_ERR(inode);
479 goto out;
480 }
481
482 *fid = AFS_FS_I(inode)->fid;
483 _leave("= %p", inode);
484 return inode;
485
486out:
487 _leave("= %d", ret);
488 return ERR_PTR(ret);
489}
490
491/*
David Howells08e0e7c2007-04-26 15:55:03 -0700492 * look up an entry in a directory
493 */
David Howells260a9802007-04-26 15:59:35 -0700494static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
Al Viro00cd8dd2012-06-10 17:13:09 -0400495 unsigned int flags)
David Howells08e0e7c2007-04-26 15:55:03 -0700496{
497 struct afs_vnode *vnode;
498 struct afs_fid fid;
499 struct inode *inode;
David Howells00d3b7a2007-04-26 15:57:07 -0700500 struct key *key;
David Howells08e0e7c2007-04-26 15:55:03 -0700501 int ret;
502
David Howells260a9802007-04-26 15:59:35 -0700503 vnode = AFS_FS_I(dir);
504
Al Viroa4555892014-10-21 20:11:25 -0400505 _enter("{%x:%u},%p{%pd},",
506 vnode->fid.vid, vnode->fid.vnode, dentry, dentry);
David Howells260a9802007-04-26 15:59:35 -0700507
David Howells2b0143b2015-03-17 22:25:59 +0000508 ASSERTCMP(d_inode(dentry), ==, NULL);
David Howells08e0e7c2007-04-26 15:55:03 -0700509
David Howells45222b92007-05-10 22:22:20 -0700510 if (dentry->d_name.len >= AFSNAMEMAX) {
David Howells08e0e7c2007-04-26 15:55:03 -0700511 _leave(" = -ENAMETOOLONG");
512 return ERR_PTR(-ENAMETOOLONG);
513 }
514
David Howells08e0e7c2007-04-26 15:55:03 -0700515 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
516 _leave(" = -ESTALE");
517 return ERR_PTR(-ESTALE);
518 }
519
David Howells00d3b7a2007-04-26 15:57:07 -0700520 key = afs_request_key(vnode->volume->cell);
521 if (IS_ERR(key)) {
522 _leave(" = %ld [key]", PTR_ERR(key));
David Howellse231c2e2008-02-07 00:15:26 -0800523 return ERR_CAST(key);
David Howells00d3b7a2007-04-26 15:57:07 -0700524 }
525
David Howells260a9802007-04-26 15:59:35 -0700526 ret = afs_validate(vnode, key);
David Howells08e0e7c2007-04-26 15:55:03 -0700527 if (ret < 0) {
David Howells00d3b7a2007-04-26 15:57:07 -0700528 key_put(key);
David Howells260a9802007-04-26 15:59:35 -0700529 _leave(" = %d [val]", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 return ERR_PTR(ret);
531 }
532
David Howells260a9802007-04-26 15:59:35 -0700533 ret = afs_do_lookup(dir, dentry, &fid, key);
534 if (ret < 0) {
wangleibec5eb62010-08-11 09:38:04 +0100535 inode = afs_try_auto_mntpt(ret, dentry, dir, key, &fid);
536 if (!IS_ERR(inode)) {
537 key_put(key);
538 goto success;
539 }
540
541 ret = PTR_ERR(inode);
David Howells260a9802007-04-26 15:59:35 -0700542 key_put(key);
543 if (ret == -ENOENT) {
544 d_add(dentry, NULL);
545 _leave(" = NULL [negative]");
546 return NULL;
547 }
548 _leave(" = %d [do]", ret);
549 return ERR_PTR(ret);
550 }
551 dentry->d_fsdata = (void *)(unsigned long) vnode->status.data_version;
552
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 /* instantiate the dentry */
David Howells260a9802007-04-26 15:59:35 -0700554 inode = afs_iget(dir->i_sb, key, &fid, NULL, NULL);
David Howells00d3b7a2007-04-26 15:57:07 -0700555 key_put(key);
David Howells08e0e7c2007-04-26 15:55:03 -0700556 if (IS_ERR(inode)) {
557 _leave(" = %ld", PTR_ERR(inode));
David Howellse231c2e2008-02-07 00:15:26 -0800558 return ERR_CAST(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
560
wangleibec5eb62010-08-11 09:38:04 +0100561success:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 d_add(dentry, inode);
David Howellsd6e43f72011-06-14 00:45:44 +0100563 _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%u }",
David Howells08e0e7c2007-04-26 15:55:03 -0700564 fid.vnode,
565 fid.unique,
David Howells2b0143b2015-03-17 22:25:59 +0000566 d_inode(dentry)->i_ino,
567 d_inode(dentry)->i_generation);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
569 return NULL;
David Howellsec268152007-04-26 15:49:28 -0700570}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572/*
573 * check that a dentry lookup hit has found a valid entry
574 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
575 * inode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 */
Al Viro0b728e12012-06-10 16:03:43 -0400577static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578{
David Howells260a9802007-04-26 15:59:35 -0700579 struct afs_vnode *vnode, *dir;
Artem Bityutskiydd0d9a42009-07-09 10:44:30 +0100580 struct afs_fid uninitialized_var(fid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 struct dentry *parent;
David Howells00d3b7a2007-04-26 15:57:07 -0700582 struct key *key;
David Howells260a9802007-04-26 15:59:35 -0700583 void *dir_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 int ret;
585
Al Viro0b728e12012-06-10 16:03:43 -0400586 if (flags & LOOKUP_RCU)
Nick Piggin34286d62011-01-07 17:49:57 +1100587 return -ECHILD;
588
David Howells2b0143b2015-03-17 22:25:59 +0000589 vnode = AFS_FS_I(d_inode(dentry));
David Howells08e0e7c2007-04-26 15:55:03 -0700590
David Howells2b0143b2015-03-17 22:25:59 +0000591 if (d_really_is_positive(dentry))
Al Viroa4555892014-10-21 20:11:25 -0400592 _enter("{v={%x:%u} n=%pd fl=%lx},",
593 vnode->fid.vid, vnode->fid.vnode, dentry,
David Howells260a9802007-04-26 15:59:35 -0700594 vnode->flags);
595 else
Al Viroa4555892014-10-21 20:11:25 -0400596 _enter("{neg n=%pd}", dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
David Howells260a9802007-04-26 15:59:35 -0700598 key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell);
David Howells00d3b7a2007-04-26 15:57:07 -0700599 if (IS_ERR(key))
600 key = NULL;
601
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 /* lock down the parent dentry so we can peer at it */
David Howells08e0e7c2007-04-26 15:55:03 -0700603 parent = dget_parent(dentry);
David Howells2b0143b2015-03-17 22:25:59 +0000604 dir = AFS_FS_I(d_inode(parent));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
David Howells260a9802007-04-26 15:59:35 -0700606 /* validate the parent directory */
607 if (test_bit(AFS_VNODE_MODIFIED, &dir->flags))
608 afs_validate(dir, key);
609
610 if (test_bit(AFS_VNODE_DELETED, &dir->flags)) {
Al Viroa4555892014-10-21 20:11:25 -0400611 _debug("%pd: parent dir deleted", dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 goto out_bad;
613 }
614
David Howells260a9802007-04-26 15:59:35 -0700615 dir_version = (void *) (unsigned long) dir->status.data_version;
616 if (dentry->d_fsdata == dir_version)
617 goto out_valid; /* the dir contents are unchanged */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
David Howells260a9802007-04-26 15:59:35 -0700619 _debug("dir modified");
620
621 /* search the directory for this vnode */
622 ret = afs_do_lookup(&dir->vfs_inode, dentry, &fid, key);
623 switch (ret) {
624 case 0:
625 /* the filename maps to something */
David Howells2b0143b2015-03-17 22:25:59 +0000626 if (d_really_is_negative(dentry))
David Howells260a9802007-04-26 15:59:35 -0700627 goto out_bad;
David Howells2b0143b2015-03-17 22:25:59 +0000628 if (is_bad_inode(d_inode(dentry))) {
Al Viroa4555892014-10-21 20:11:25 -0400629 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
630 dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 goto out_bad;
632 }
633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 /* if the vnode ID has changed, then the dirent points to a
635 * different file */
David Howells08e0e7c2007-04-26 15:55:03 -0700636 if (fid.vnode != vnode->fid.vnode) {
Al Viroa4555892014-10-21 20:11:25 -0400637 _debug("%pd: dirent changed [%u != %u]",
638 dentry, fid.vnode,
David Howells08e0e7c2007-04-26 15:55:03 -0700639 vnode->fid.vnode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 goto not_found;
641 }
642
643 /* if the vnode ID uniqifier has changed, then the file has
David Howells260a9802007-04-26 15:59:35 -0700644 * been deleted and replaced, and the original vnode ID has
645 * been reused */
David Howells08e0e7c2007-04-26 15:55:03 -0700646 if (fid.unique != vnode->fid.unique) {
Al Viroa4555892014-10-21 20:11:25 -0400647 _debug("%pd: file deleted (uq %u -> %u I:%u)",
648 dentry, fid.unique,
Jean Noel Cordenner7a224222008-01-28 23:58:27 -0500649 vnode->fid.unique,
David Howells2b0143b2015-03-17 22:25:59 +0000650 d_inode(dentry)->i_generation);
David Howells08e0e7c2007-04-26 15:55:03 -0700651 spin_lock(&vnode->lock);
652 set_bit(AFS_VNODE_DELETED, &vnode->flags);
653 spin_unlock(&vnode->lock);
David Howells260a9802007-04-26 15:59:35 -0700654 goto not_found;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 }
David Howells260a9802007-04-26 15:59:35 -0700656 goto out_valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
David Howells260a9802007-04-26 15:59:35 -0700658 case -ENOENT:
659 /* the filename is unknown */
Al Viroa4555892014-10-21 20:11:25 -0400660 _debug("%pd: dirent not found", dentry);
David Howells2b0143b2015-03-17 22:25:59 +0000661 if (d_really_is_positive(dentry))
David Howells260a9802007-04-26 15:59:35 -0700662 goto not_found;
663 goto out_valid;
David Howells08e0e7c2007-04-26 15:55:03 -0700664
David Howells260a9802007-04-26 15:59:35 -0700665 default:
Al Viroa4555892014-10-21 20:11:25 -0400666 _debug("failed to iterate dir %pd: %d",
667 parent, ret);
David Howells08e0e7c2007-04-26 15:55:03 -0700668 goto out_bad;
669 }
670
David Howellsec268152007-04-26 15:49:28 -0700671out_valid:
David Howells260a9802007-04-26 15:59:35 -0700672 dentry->d_fsdata = dir_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 dput(parent);
David Howells00d3b7a2007-04-26 15:57:07 -0700674 key_put(key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 _leave(" = 1 [valid]");
676 return 1;
677
678 /* the dirent, if it exists, now points to a different vnode */
David Howellsec268152007-04-26 15:49:28 -0700679not_found:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 spin_lock(&dentry->d_lock);
681 dentry->d_flags |= DCACHE_NFSFS_RENAMED;
682 spin_unlock(&dentry->d_lock);
683
David Howellsec268152007-04-26 15:49:28 -0700684out_bad:
Al Viroa4555892014-10-21 20:11:25 -0400685 _debug("dropping dentry %pd2", dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 dput(parent);
David Howells00d3b7a2007-04-26 15:57:07 -0700687 key_put(key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
689 _leave(" = 0 [bad]");
690 return 0;
David Howellsec268152007-04-26 15:49:28 -0700691}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693/*
694 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
695 * sleep)
696 * - called from dput() when d_count is going to 0.
697 * - return 1 to request dentry be unhashed, 0 otherwise
698 */
Nick Pigginfe15ce42011-01-07 17:49:23 +1100699static int afs_d_delete(const struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
Al Viroa4555892014-10-21 20:11:25 -0400701 _enter("%pd", dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
703 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
704 goto zap;
705
David Howells2b0143b2015-03-17 22:25:59 +0000706 if (d_really_is_positive(dentry) &&
707 (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(d_inode(dentry))->flags) ||
708 test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags)))
wangleibec5eb62010-08-11 09:38:04 +0100709 goto zap;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
711 _leave(" = 0 [keep]");
712 return 0;
713
David Howellsec268152007-04-26 15:49:28 -0700714zap:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 _leave(" = 1 [zap]");
716 return 1;
David Howellsec268152007-04-26 15:49:28 -0700717}
David Howells260a9802007-04-26 15:59:35 -0700718
719/*
720 * handle dentry release
721 */
722static void afs_d_release(struct dentry *dentry)
723{
Al Viroa4555892014-10-21 20:11:25 -0400724 _enter("%pd", dentry);
David Howells260a9802007-04-26 15:59:35 -0700725}
726
727/*
728 * create a directory on an AFS filesystem
729 */
Al Viro18bb1db2011-07-26 01:41:39 -0400730static int afs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
David Howells260a9802007-04-26 15:59:35 -0700731{
732 struct afs_file_status status;
733 struct afs_callback cb;
734 struct afs_server *server;
735 struct afs_vnode *dvnode, *vnode;
736 struct afs_fid fid;
737 struct inode *inode;
738 struct key *key;
739 int ret;
740
741 dvnode = AFS_FS_I(dir);
742
Al Viroa4555892014-10-21 20:11:25 -0400743 _enter("{%x:%u},{%pd},%ho",
744 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);
David Howells260a9802007-04-26 15:59:35 -0700745
David Howells260a9802007-04-26 15:59:35 -0700746 key = afs_request_key(dvnode->volume->cell);
747 if (IS_ERR(key)) {
748 ret = PTR_ERR(key);
749 goto error;
750 }
751
752 mode |= S_IFDIR;
753 ret = afs_vnode_create(dvnode, key, dentry->d_name.name,
754 mode, &fid, &status, &cb, &server);
755 if (ret < 0)
756 goto mkdir_error;
757
758 inode = afs_iget(dir->i_sb, key, &fid, &status, &cb);
759 if (IS_ERR(inode)) {
760 /* ENOMEM at a really inconvenient time - just abandon the new
761 * directory on the server */
762 ret = PTR_ERR(inode);
763 goto iget_error;
764 }
765
766 /* apply the status report we've got for the new vnode */
767 vnode = AFS_FS_I(inode);
768 spin_lock(&vnode->lock);
769 vnode->update_cnt++;
770 spin_unlock(&vnode->lock);
771 afs_vnode_finalise_status_update(vnode, server);
772 afs_put_server(server);
773
774 d_instantiate(dentry, inode);
775 if (d_unhashed(dentry)) {
776 _debug("not hashed");
777 d_rehash(dentry);
778 }
779 key_put(key);
780 _leave(" = 0");
781 return 0;
782
783iget_error:
784 afs_put_server(server);
785mkdir_error:
786 key_put(key);
787error:
788 d_drop(dentry);
789 _leave(" = %d", ret);
790 return ret;
791}
792
793/*
794 * remove a directory from an AFS filesystem
795 */
796static int afs_rmdir(struct inode *dir, struct dentry *dentry)
797{
798 struct afs_vnode *dvnode, *vnode;
799 struct key *key;
800 int ret;
801
802 dvnode = AFS_FS_I(dir);
803
Al Viroa4555892014-10-21 20:11:25 -0400804 _enter("{%x:%u},{%pd}",
805 dvnode->fid.vid, dvnode->fid.vnode, dentry);
David Howells260a9802007-04-26 15:59:35 -0700806
David Howells260a9802007-04-26 15:59:35 -0700807 key = afs_request_key(dvnode->volume->cell);
808 if (IS_ERR(key)) {
809 ret = PTR_ERR(key);
810 goto error;
811 }
812
813 ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, true);
814 if (ret < 0)
815 goto rmdir_error;
816
David Howells2b0143b2015-03-17 22:25:59 +0000817 if (d_really_is_positive(dentry)) {
818 vnode = AFS_FS_I(d_inode(dentry));
David Howells260a9802007-04-26 15:59:35 -0700819 clear_nlink(&vnode->vfs_inode);
820 set_bit(AFS_VNODE_DELETED, &vnode->flags);
821 afs_discard_callback_on_delete(vnode);
822 }
823
824 key_put(key);
825 _leave(" = 0");
826 return 0;
827
828rmdir_error:
829 key_put(key);
830error:
831 _leave(" = %d", ret);
832 return ret;
833}
834
835/*
836 * remove a file from an AFS filesystem
837 */
838static int afs_unlink(struct inode *dir, struct dentry *dentry)
839{
840 struct afs_vnode *dvnode, *vnode;
841 struct key *key;
842 int ret;
843
844 dvnode = AFS_FS_I(dir);
845
Al Viroa4555892014-10-21 20:11:25 -0400846 _enter("{%x:%u},{%pd}",
847 dvnode->fid.vid, dvnode->fid.vnode, dentry);
David Howells260a9802007-04-26 15:59:35 -0700848
849 ret = -ENAMETOOLONG;
David Howells45222b92007-05-10 22:22:20 -0700850 if (dentry->d_name.len >= AFSNAMEMAX)
David Howells260a9802007-04-26 15:59:35 -0700851 goto error;
852
853 key = afs_request_key(dvnode->volume->cell);
854 if (IS_ERR(key)) {
855 ret = PTR_ERR(key);
856 goto error;
857 }
858
David Howells2b0143b2015-03-17 22:25:59 +0000859 if (d_really_is_positive(dentry)) {
860 vnode = AFS_FS_I(d_inode(dentry));
David Howells260a9802007-04-26 15:59:35 -0700861
862 /* make sure we have a callback promise on the victim */
863 ret = afs_validate(vnode, key);
864 if (ret < 0)
865 goto error;
866 }
867
868 ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, false);
869 if (ret < 0)
870 goto remove_error;
871
David Howells2b0143b2015-03-17 22:25:59 +0000872 if (d_really_is_positive(dentry)) {
David Howells260a9802007-04-26 15:59:35 -0700873 /* if the file wasn't deleted due to excess hard links, the
874 * fileserver will break the callback promise on the file - if
875 * it had one - before it returns to us, and if it was deleted,
876 * it won't
877 *
878 * however, if we didn't have a callback promise outstanding,
879 * or it was outstanding on a different server, then it won't
880 * break it either...
881 */
David Howells2b0143b2015-03-17 22:25:59 +0000882 vnode = AFS_FS_I(d_inode(dentry));
David Howells260a9802007-04-26 15:59:35 -0700883 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
884 _debug("AFS_VNODE_DELETED");
885 if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags))
886 _debug("AFS_VNODE_CB_BROKEN");
887 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
888 ret = afs_validate(vnode, key);
889 _debug("nlink %d [val %d]", vnode->vfs_inode.i_nlink, ret);
890 }
891
892 key_put(key);
893 _leave(" = 0");
894 return 0;
895
896remove_error:
897 key_put(key);
898error:
899 _leave(" = %d", ret);
900 return ret;
901}
902
903/*
904 * create a regular file on an AFS filesystem
905 */
Al Viro4acdaf22011-07-26 01:42:34 -0400906static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
Al Viroebfc3b42012-06-10 18:05:36 -0400907 bool excl)
David Howells260a9802007-04-26 15:59:35 -0700908{
909 struct afs_file_status status;
910 struct afs_callback cb;
911 struct afs_server *server;
912 struct afs_vnode *dvnode, *vnode;
913 struct afs_fid fid;
914 struct inode *inode;
915 struct key *key;
916 int ret;
917
918 dvnode = AFS_FS_I(dir);
919
Al Viroa4555892014-10-21 20:11:25 -0400920 _enter("{%x:%u},{%pd},%ho,",
921 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);
David Howells260a9802007-04-26 15:59:35 -0700922
David Howells260a9802007-04-26 15:59:35 -0700923 key = afs_request_key(dvnode->volume->cell);
924 if (IS_ERR(key)) {
925 ret = PTR_ERR(key);
926 goto error;
927 }
928
929 mode |= S_IFREG;
930 ret = afs_vnode_create(dvnode, key, dentry->d_name.name,
931 mode, &fid, &status, &cb, &server);
932 if (ret < 0)
933 goto create_error;
934
935 inode = afs_iget(dir->i_sb, key, &fid, &status, &cb);
936 if (IS_ERR(inode)) {
937 /* ENOMEM at a really inconvenient time - just abandon the new
938 * directory on the server */
939 ret = PTR_ERR(inode);
940 goto iget_error;
941 }
942
943 /* apply the status report we've got for the new vnode */
944 vnode = AFS_FS_I(inode);
945 spin_lock(&vnode->lock);
946 vnode->update_cnt++;
947 spin_unlock(&vnode->lock);
948 afs_vnode_finalise_status_update(vnode, server);
949 afs_put_server(server);
950
951 d_instantiate(dentry, inode);
952 if (d_unhashed(dentry)) {
953 _debug("not hashed");
954 d_rehash(dentry);
955 }
956 key_put(key);
957 _leave(" = 0");
958 return 0;
959
960iget_error:
961 afs_put_server(server);
962create_error:
963 key_put(key);
964error:
965 d_drop(dentry);
966 _leave(" = %d", ret);
967 return ret;
968}
969
970/*
971 * create a hard link between files in an AFS filesystem
972 */
973static int afs_link(struct dentry *from, struct inode *dir,
974 struct dentry *dentry)
975{
976 struct afs_vnode *dvnode, *vnode;
977 struct key *key;
978 int ret;
979
David Howells2b0143b2015-03-17 22:25:59 +0000980 vnode = AFS_FS_I(d_inode(from));
David Howells260a9802007-04-26 15:59:35 -0700981 dvnode = AFS_FS_I(dir);
982
Al Viroa4555892014-10-21 20:11:25 -0400983 _enter("{%x:%u},{%x:%u},{%pd}",
David Howells260a9802007-04-26 15:59:35 -0700984 vnode->fid.vid, vnode->fid.vnode,
985 dvnode->fid.vid, dvnode->fid.vnode,
Al Viroa4555892014-10-21 20:11:25 -0400986 dentry);
David Howells260a9802007-04-26 15:59:35 -0700987
David Howells260a9802007-04-26 15:59:35 -0700988 key = afs_request_key(dvnode->volume->cell);
989 if (IS_ERR(key)) {
990 ret = PTR_ERR(key);
991 goto error;
992 }
993
994 ret = afs_vnode_link(dvnode, vnode, key, dentry->d_name.name);
995 if (ret < 0)
996 goto link_error;
997
Al Viro7de9c6ee2010-10-23 11:11:40 -0400998 ihold(&vnode->vfs_inode);
David Howells260a9802007-04-26 15:59:35 -0700999 d_instantiate(dentry, &vnode->vfs_inode);
1000 key_put(key);
1001 _leave(" = 0");
1002 return 0;
1003
1004link_error:
1005 key_put(key);
1006error:
1007 d_drop(dentry);
1008 _leave(" = %d", ret);
1009 return ret;
1010}
1011
1012/*
1013 * create a symlink in an AFS filesystem
1014 */
1015static int afs_symlink(struct inode *dir, struct dentry *dentry,
1016 const char *content)
1017{
1018 struct afs_file_status status;
1019 struct afs_server *server;
1020 struct afs_vnode *dvnode, *vnode;
1021 struct afs_fid fid;
1022 struct inode *inode;
1023 struct key *key;
1024 int ret;
1025
1026 dvnode = AFS_FS_I(dir);
1027
Al Viroa4555892014-10-21 20:11:25 -04001028 _enter("{%x:%u},{%pd},%s",
1029 dvnode->fid.vid, dvnode->fid.vnode, dentry,
David Howells260a9802007-04-26 15:59:35 -07001030 content);
1031
David Howells260a9802007-04-26 15:59:35 -07001032 ret = -EINVAL;
David Howells45222b92007-05-10 22:22:20 -07001033 if (strlen(content) >= AFSPATHMAX)
David Howells260a9802007-04-26 15:59:35 -07001034 goto error;
1035
1036 key = afs_request_key(dvnode->volume->cell);
1037 if (IS_ERR(key)) {
1038 ret = PTR_ERR(key);
1039 goto error;
1040 }
1041
1042 ret = afs_vnode_symlink(dvnode, key, dentry->d_name.name, content,
1043 &fid, &status, &server);
1044 if (ret < 0)
1045 goto create_error;
1046
1047 inode = afs_iget(dir->i_sb, key, &fid, &status, NULL);
1048 if (IS_ERR(inode)) {
1049 /* ENOMEM at a really inconvenient time - just abandon the new
1050 * directory on the server */
1051 ret = PTR_ERR(inode);
1052 goto iget_error;
1053 }
1054
1055 /* apply the status report we've got for the new vnode */
1056 vnode = AFS_FS_I(inode);
1057 spin_lock(&vnode->lock);
1058 vnode->update_cnt++;
1059 spin_unlock(&vnode->lock);
1060 afs_vnode_finalise_status_update(vnode, server);
1061 afs_put_server(server);
1062
1063 d_instantiate(dentry, inode);
1064 if (d_unhashed(dentry)) {
1065 _debug("not hashed");
1066 d_rehash(dentry);
1067 }
1068 key_put(key);
1069 _leave(" = 0");
1070 return 0;
1071
1072iget_error:
1073 afs_put_server(server);
1074create_error:
1075 key_put(key);
1076error:
1077 d_drop(dentry);
1078 _leave(" = %d", ret);
1079 return ret;
1080}
1081
1082/*
1083 * rename a file in an AFS filesystem and/or move it between directories
1084 */
1085static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
1086 struct inode *new_dir, struct dentry *new_dentry)
1087{
1088 struct afs_vnode *orig_dvnode, *new_dvnode, *vnode;
1089 struct key *key;
1090 int ret;
1091
David Howells2b0143b2015-03-17 22:25:59 +00001092 vnode = AFS_FS_I(d_inode(old_dentry));
David Howells260a9802007-04-26 15:59:35 -07001093 orig_dvnode = AFS_FS_I(old_dir);
1094 new_dvnode = AFS_FS_I(new_dir);
1095
Al Viroa4555892014-10-21 20:11:25 -04001096 _enter("{%x:%u},{%x:%u},{%x:%u},{%pd}",
David Howells260a9802007-04-26 15:59:35 -07001097 orig_dvnode->fid.vid, orig_dvnode->fid.vnode,
1098 vnode->fid.vid, vnode->fid.vnode,
1099 new_dvnode->fid.vid, new_dvnode->fid.vnode,
Al Viroa4555892014-10-21 20:11:25 -04001100 new_dentry);
David Howells260a9802007-04-26 15:59:35 -07001101
David Howells260a9802007-04-26 15:59:35 -07001102 key = afs_request_key(orig_dvnode->volume->cell);
1103 if (IS_ERR(key)) {
1104 ret = PTR_ERR(key);
1105 goto error;
1106 }
1107
1108 ret = afs_vnode_rename(orig_dvnode, new_dvnode, key,
1109 old_dentry->d_name.name,
1110 new_dentry->d_name.name);
1111 if (ret < 0)
1112 goto rename_error;
1113 key_put(key);
1114 _leave(" = 0");
1115 return 0;
1116
1117rename_error:
1118 key_put(key);
1119error:
1120 d_drop(new_dentry);
1121 _leave(" = %d", ret);
1122 return ret;
1123}