blob: eb3b1898da462afd84c62bd9646eb968d4c84225 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * Mostly platform independent upcall operations to Venus:
4 * -- upcalls
5 * -- upcall routines
6 *
7 * Linux 2.0 version
8 * Copyright (C) 1996 Peter J. Braam <braam@maths.ox.ac.uk>,
9 * Michael Callahan <callahan@maths.ox.ac.uk>
10 *
11 * Redone for Linux 2.1
12 * Copyright (C) 1997 Carnegie Mellon University
13 *
14 * Carnegie Mellon University encourages users of this code to contribute
15 * improvements to the Coda project. Contact Peter Braam <coda@cs.cmu.edu>.
16 */
17
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/signal.h>
Ingo Molnar3f07c012017-02-08 18:51:30 +010019#include <linux/sched/signal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/types.h>
21#include <linux/kernel.h>
22#include <linux/mm.h>
23#include <linux/time.h>
24#include <linux/fs.h>
25#include <linux/file.h>
26#include <linux/stat.h>
27#include <linux/errno.h>
28#include <linux/string.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090029#include <linux/slab.h>
Yoshihisa Abeda47c192010-10-25 02:03:46 -040030#include <linux/mutex.h>
Fabian Frederick834b46c2014-08-08 14:20:33 -070031#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/vmalloc.h>
33#include <linux/vfs.h>
34
35#include <linux/coda.h>
David Howells8fc8b9d2019-07-16 16:28:47 -070036#include "coda_psdev.h"
Al Viro31a203d2011-01-12 16:36:09 -050037#include "coda_linux.h"
38#include "coda_cache.h"
Jan Harkes3cf01f22007-07-19 01:48:51 -070039
40#include "coda_int.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Jan Harkesa1b0aa82007-07-19 01:48:50 -070042static int coda_upcall(struct venus_comm *vc, int inSize, int *outSize,
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 union inputArgs *buffer);
44
45static void *alloc_upcall(int opcode, int size)
46{
47 union inputArgs *inp;
48
Dan Carpenter4dc48192019-07-16 16:28:38 -070049 inp = kvzalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 if (!inp)
51 return ERR_PTR(-ENOMEM);
52
53 inp->ih.opcode = opcode;
Eric W. Biederman9fd973e2013-01-30 18:50:54 -080054 inp->ih.pid = task_pid_nr_ns(current, &init_pid_ns);
55 inp->ih.pgid = task_pgrp_nr_ns(current, &init_pid_ns);
Eric W. Biedermand83f5902013-01-30 19:21:14 -080056 inp->ih.uid = from_kuid(&init_user_ns, current_fsuid());
Adrian Bunkde0ca062008-07-25 01:46:34 -070057
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 return (void*)inp;
59}
60
61#define UPARG(op)\
62do {\
63 inp = (union inputArgs *)alloc_upcall(op, insize); \
64 if (IS_ERR(inp)) { return PTR_ERR(inp); }\
65 outp = (union outputArgs *)(inp); \
66 outsize = insize; \
67} while (0)
68
69#define INSIZE(tag) sizeof(struct coda_ ## tag ## _in)
70#define OUTSIZE(tag) sizeof(struct coda_ ## tag ## _out)
71#define SIZE(tag) max_t(unsigned int, INSIZE(tag), OUTSIZE(tag))
72
73
74/* the upcalls */
75int venus_rootfid(struct super_block *sb, struct CodaFid *fidp)
76{
77 union inputArgs *inp;
78 union outputArgs *outp;
79 int insize, outsize, error;
80
81 insize = SIZE(root);
82 UPARG(CODA_ROOT);
83
Jan Harkesa1b0aa82007-07-19 01:48:50 -070084 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Jan Harkes970648e2007-07-19 01:48:48 -070085 if (!error)
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 *fidp = outp->coda_root.VFid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Dan Carpenter936dae42019-07-16 16:28:41 -070088 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 return error;
90}
91
92int venus_getattr(struct super_block *sb, struct CodaFid *fid,
93 struct coda_vattr *attr)
94{
95 union inputArgs *inp;
96 union outputArgs *outp;
97 int insize, outsize, error;
98
99 insize = SIZE(getattr);
100 UPARG(CODA_GETATTR);
101 inp->coda_getattr.VFid = *fid;
102
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700103 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Jan Harkes970648e2007-07-19 01:48:48 -0700104 if (!error)
105 *attr = outp->coda_getattr.attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
Dan Carpenter936dae42019-07-16 16:28:41 -0700107 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 return error;
109}
110
111int venus_setattr(struct super_block *sb, struct CodaFid *fid,
112 struct coda_vattr *vattr)
113{
114 union inputArgs *inp;
115 union outputArgs *outp;
116 int insize, outsize, error;
117
118 insize = SIZE(setattr);
119 UPARG(CODA_SETATTR);
120
121 inp->coda_setattr.VFid = *fid;
122 inp->coda_setattr.attr = *vattr;
123
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700124 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
Dan Carpenter936dae42019-07-16 16:28:41 -0700126 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 return error;
128}
129
130int venus_lookup(struct super_block *sb, struct CodaFid *fid,
131 const char *name, int length, int * type,
132 struct CodaFid *resfid)
133{
134 union inputArgs *inp;
135 union outputArgs *outp;
136 int insize, outsize, error;
137 int offset;
138
139 offset = INSIZE(lookup);
140 insize = max_t(unsigned int, offset + length +1, OUTSIZE(lookup));
141 UPARG(CODA_LOOKUP);
142
143 inp->coda_lookup.VFid = *fid;
144 inp->coda_lookup.name = offset;
145 inp->coda_lookup.flags = CLU_CASE_SENSITIVE;
146 /* send Venus a null terminated string */
147 memcpy((char *)(inp) + offset, name, length);
148 *((char *)inp + offset + length) = '\0';
149
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700150 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Jan Harkes970648e2007-07-19 01:48:48 -0700151 if (!error) {
152 *resfid = outp->coda_lookup.VFid;
153 *type = outp->coda_lookup.vtype;
154 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Dan Carpenter936dae42019-07-16 16:28:41 -0700156 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 return error;
158}
159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
Eric W. Biedermand83f5902013-01-30 19:21:14 -0800161 kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162{
163 union inputArgs *inp;
164 union outputArgs *outp;
165 int insize, outsize, error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
167 insize = SIZE(release);
168 UPARG(CODA_CLOSE);
169
Eric W. Biedermand83f5902013-01-30 19:21:14 -0800170 inp->ih.uid = from_kuid(&init_user_ns, uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 inp->coda_close.VFid = *fid;
172 inp->coda_close.flags = flags;
173
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700174 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Dan Carpenter936dae42019-07-16 16:28:41 -0700176 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 return error;
178}
179
180int venus_open(struct super_block *sb, struct CodaFid *fid,
181 int flags, struct file **fh)
182{
183 union inputArgs *inp;
184 union outputArgs *outp;
185 int insize, outsize, error;
186
187 insize = SIZE(open_by_fd);
188 UPARG(CODA_OPEN_BY_FD);
189
Jan Harkes38c2e432007-07-19 01:48:41 -0700190 inp->coda_open_by_fd.VFid = *fid;
191 inp->coda_open_by_fd.flags = flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700193 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Jan Harkes38c2e432007-07-19 01:48:41 -0700194 if (!error)
195 *fh = outp->coda_open_by_fd.fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
Dan Carpenter936dae42019-07-16 16:28:41 -0700197 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return error;
199}
200
201int venus_mkdir(struct super_block *sb, struct CodaFid *dirfid,
202 const char *name, int length,
203 struct CodaFid *newfid, struct coda_vattr *attrs)
204{
205 union inputArgs *inp;
206 union outputArgs *outp;
207 int insize, outsize, error;
208 int offset;
209
210 offset = INSIZE(mkdir);
211 insize = max_t(unsigned int, offset + length + 1, OUTSIZE(mkdir));
212 UPARG(CODA_MKDIR);
213
214 inp->coda_mkdir.VFid = *dirfid;
215 inp->coda_mkdir.attr = *attrs;
216 inp->coda_mkdir.name = offset;
217 /* Venus must get null terminated string */
218 memcpy((char *)(inp) + offset, name, length);
219 *((char *)inp + offset + length) = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700221 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Jan Harkes970648e2007-07-19 01:48:48 -0700222 if (!error) {
223 *attrs = outp->coda_mkdir.attr;
224 *newfid = outp->coda_mkdir.VFid;
225 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
Dan Carpenter936dae42019-07-16 16:28:41 -0700227 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 return error;
229}
230
231
232int venus_rename(struct super_block *sb, struct CodaFid *old_fid,
233 struct CodaFid *new_fid, size_t old_length,
234 size_t new_length, const char *old_name,
235 const char *new_name)
236{
237 union inputArgs *inp;
238 union outputArgs *outp;
239 int insize, outsize, error;
240 int offset, s;
241
242 offset = INSIZE(rename);
243 insize = max_t(unsigned int, offset + new_length + old_length + 8,
244 OUTSIZE(rename));
245 UPARG(CODA_RENAME);
246
247 inp->coda_rename.sourceFid = *old_fid;
248 inp->coda_rename.destFid = *new_fid;
249 inp->coda_rename.srcname = offset;
250
251 /* Venus must receive an null terminated string */
252 s = ( old_length & ~0x3) +4; /* round up to word boundary */
253 memcpy((char *)(inp) + offset, old_name, old_length);
254 *((char *)inp + offset + old_length) = '\0';
255
256 /* another null terminated string for Venus */
257 offset += s;
258 inp->coda_rename.destname = offset;
259 s = ( new_length & ~0x3) +4; /* round up to word boundary */
260 memcpy((char *)(inp) + offset, new_name, new_length);
261 *((char *)inp + offset + new_length) = '\0';
262
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700263 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
Dan Carpenter936dae42019-07-16 16:28:41 -0700265 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 return error;
267}
268
269int venus_create(struct super_block *sb, struct CodaFid *dirfid,
270 const char *name, int length, int excl, int mode,
271 struct CodaFid *newfid, struct coda_vattr *attrs)
272{
273 union inputArgs *inp;
274 union outputArgs *outp;
275 int insize, outsize, error;
276 int offset;
277
278 offset = INSIZE(create);
279 insize = max_t(unsigned int, offset + length + 1, OUTSIZE(create));
280 UPARG(CODA_CREATE);
281
282 inp->coda_create.VFid = *dirfid;
283 inp->coda_create.attr.va_mode = mode;
284 inp->coda_create.excl = excl;
285 inp->coda_create.mode = mode;
286 inp->coda_create.name = offset;
287
288 /* Venus must get null terminated string */
289 memcpy((char *)(inp) + offset, name, length);
290 *((char *)inp + offset + length) = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700292 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Jan Harkes970648e2007-07-19 01:48:48 -0700293 if (!error) {
294 *attrs = outp->coda_create.attr;
295 *newfid = outp->coda_create.VFid;
296 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Dan Carpenter936dae42019-07-16 16:28:41 -0700298 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 return error;
300}
301
302int venus_rmdir(struct super_block *sb, struct CodaFid *dirfid,
303 const char *name, int length)
304{
305 union inputArgs *inp;
306 union outputArgs *outp;
307 int insize, outsize, error;
308 int offset;
309
310 offset = INSIZE(rmdir);
311 insize = max_t(unsigned int, offset + length + 1, OUTSIZE(rmdir));
312 UPARG(CODA_RMDIR);
313
314 inp->coda_rmdir.VFid = *dirfid;
315 inp->coda_rmdir.name = offset;
316 memcpy((char *)(inp) + offset, name, length);
317 *((char *)inp + offset + length) = '\0';
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700318
319 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320
Dan Carpenter936dae42019-07-16 16:28:41 -0700321 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 return error;
323}
324
325int venus_remove(struct super_block *sb, struct CodaFid *dirfid,
326 const char *name, int length)
327{
328 union inputArgs *inp;
329 union outputArgs *outp;
330 int error=0, insize, outsize, offset;
331
332 offset = INSIZE(remove);
333 insize = max_t(unsigned int, offset + length + 1, OUTSIZE(remove));
334 UPARG(CODA_REMOVE);
335
336 inp->coda_remove.VFid = *dirfid;
337 inp->coda_remove.name = offset;
338 memcpy((char *)(inp) + offset, name, length);
339 *((char *)inp + offset + length) = '\0';
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700340
341 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
Dan Carpenter936dae42019-07-16 16:28:41 -0700343 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 return error;
345}
346
347int venus_readlink(struct super_block *sb, struct CodaFid *fid,
348 char *buffer, int *length)
349{
350 union inputArgs *inp;
351 union outputArgs *outp;
352 int insize, outsize, error;
353 int retlen;
354 char *result;
355
356 insize = max_t(unsigned int,
Jan Harkes3725e9d2015-09-09 15:38:01 -0700357 INSIZE(readlink), OUTSIZE(readlink)+ *length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 UPARG(CODA_READLINK);
359
360 inp->coda_readlink.VFid = *fid;
Jan Harkes970648e2007-07-19 01:48:48 -0700361
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700362 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Jan Harkes970648e2007-07-19 01:48:48 -0700363 if (!error) {
364 retlen = outp->coda_readlink.count;
Jan Harkes3725e9d2015-09-09 15:38:01 -0700365 if (retlen >= *length)
366 retlen = *length - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 *length = retlen;
368 result = (char *)outp + (long)outp->coda_readlink.data;
369 memcpy(buffer, result, retlen);
370 *(buffer + retlen) = '\0';
371 }
Jan Harkes970648e2007-07-19 01:48:48 -0700372
Dan Carpenter936dae42019-07-16 16:28:41 -0700373 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 return error;
375}
376
377
378
379int venus_link(struct super_block *sb, struct CodaFid *fid,
380 struct CodaFid *dirfid, const char *name, int len )
381{
382 union inputArgs *inp;
383 union outputArgs *outp;
384 int insize, outsize, error;
385 int offset;
386
387 offset = INSIZE(link);
388 insize = max_t(unsigned int, offset + len + 1, OUTSIZE(link));
389 UPARG(CODA_LINK);
390
391 inp->coda_link.sourceFid = *fid;
392 inp->coda_link.destFid = *dirfid;
393 inp->coda_link.tname = offset;
394
395 /* make sure strings are null terminated */
396 memcpy((char *)(inp) + offset, name, len);
397 *((char *)inp + offset + len) = '\0';
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700398
399 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Dan Carpenter936dae42019-07-16 16:28:41 -0700401 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 return error;
403}
404
405int venus_symlink(struct super_block *sb, struct CodaFid *fid,
406 const char *name, int len,
407 const char *symname, int symlen)
408{
409 union inputArgs *inp;
410 union outputArgs *outp;
411 int insize, outsize, error;
412 int offset, s;
413
414 offset = INSIZE(symlink);
415 insize = max_t(unsigned int, offset + len + symlen + 8, OUTSIZE(symlink));
416 UPARG(CODA_SYMLINK);
417
418 /* inp->coda_symlink.attr = *tva; XXXXXX */
419 inp->coda_symlink.VFid = *fid;
420
421 /* Round up to word boundary and null terminate */
422 inp->coda_symlink.srcname = offset;
423 s = ( symlen & ~0x3 ) + 4;
424 memcpy((char *)(inp) + offset, symname, symlen);
425 *((char *)inp + offset + symlen) = '\0';
426
427 /* Round up to word boundary and null terminate */
428 offset += s;
429 inp->coda_symlink.tname = offset;
430 s = (len & ~0x3) + 4;
431 memcpy((char *)(inp) + offset, name, len);
432 *((char *)inp + offset + len) = '\0';
433
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700434 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
Dan Carpenter936dae42019-07-16 16:28:41 -0700436 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 return error;
438}
439
440int venus_fsync(struct super_block *sb, struct CodaFid *fid)
441{
442 union inputArgs *inp;
443 union outputArgs *outp;
444 int insize, outsize, error;
445
446 insize=SIZE(fsync);
447 UPARG(CODA_FSYNC);
448
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700449 inp->coda_fsync.VFid = *fid;
Jan Harkesd337b662017-09-27 15:52:12 -0400450 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Dan Carpenter936dae42019-07-16 16:28:41 -0700452 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return error;
454}
455
456int venus_access(struct super_block *sb, struct CodaFid *fid, int mask)
457{
458 union inputArgs *inp;
459 union outputArgs *outp;
460 int insize, outsize, error;
461
462 insize = SIZE(access);
463 UPARG(CODA_ACCESS);
464
465 inp->coda_access.VFid = *fid;
466 inp->coda_access.flags = mask;
467
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700468 error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
Dan Carpenter936dae42019-07-16 16:28:41 -0700470 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 return error;
472}
473
474
475int venus_pioctl(struct super_block *sb, struct CodaFid *fid,
476 unsigned int cmd, struct PioctlData *data)
477{
478 union inputArgs *inp;
479 union outputArgs *outp;
480 int insize, outsize, error;
481 int iocsize;
482
483 insize = VC_MAXMSGSIZE;
484 UPARG(CODA_IOCTL);
485
486 /* build packet for Venus */
487 if (data->vi.in_size > VC_MAXDATASIZE) {
488 error = -EINVAL;
489 goto exit;
490 }
491
492 if (data->vi.out_size > VC_MAXDATASIZE) {
493 error = -EINVAL;
494 goto exit;
495 }
496
497 inp->coda_ioctl.VFid = *fid;
498
499 /* the cmd field was mutated by increasing its size field to
500 * reflect the path and follow args. We need to subtract that
501 * out before sending the command to Venus. */
502 inp->coda_ioctl.cmd = (cmd & ~(PIOCPARM_MASK << 16));
503 iocsize = ((cmd >> 16) & PIOCPARM_MASK) - sizeof(char *) - sizeof(int);
504 inp->coda_ioctl.cmd |= (iocsize & PIOCPARM_MASK) << 16;
505
506 /* in->coda_ioctl.rwflag = flag; */
507 inp->coda_ioctl.len = data->vi.in_size;
508 inp->coda_ioctl.data = (char *)(INSIZE(ioctl));
509
510 /* get the data out of user space */
Fabian Frederickd9b4b312014-06-06 14:36:18 -0700511 if (copy_from_user((char *)inp + (long)inp->coda_ioctl.data,
512 data->vi.in, data->vi.in_size)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 error = -EINVAL;
514 goto exit;
515 }
516
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700517 error = coda_upcall(coda_vcp(sb), SIZE(ioctl) + data->vi.in_size,
518 &outsize, inp);
519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 if (error) {
Fabian Frederick6d6bd942014-06-06 14:36:20 -0700521 pr_warn("%s: Venus returns: %d for %s\n",
522 __func__, error, coda_f2s(fid));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 goto exit;
524 }
525
526 if (outsize < (long)outp->coda_ioctl.data + outp->coda_ioctl.len) {
527 error = -EINVAL;
528 goto exit;
529 }
530
531 /* Copy out the OUT buffer. */
532 if (outp->coda_ioctl.len > data->vi.out_size) {
533 error = -EINVAL;
534 goto exit;
535 }
536
537 /* Copy out the OUT buffer. */
538 if (copy_to_user(data->vi.out,
539 (char *)outp + (long)outp->coda_ioctl.data,
540 outp->coda_ioctl.len)) {
541 error = -EFAULT;
542 goto exit;
543 }
544
545 exit:
Dan Carpenter936dae42019-07-16 16:28:41 -0700546 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 return error;
548}
549
David Howells726c3342006-06-23 02:02:58 -0700550int venus_statfs(struct dentry *dentry, struct kstatfs *sfs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551{
552 union inputArgs *inp;
553 union outputArgs *outp;
554 int insize, outsize, error;
555
Fabian Frederick50e9a6e2019-07-16 16:28:57 -0700556 insize = SIZE(statfs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 UPARG(CODA_STATFS);
558
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700559 error = coda_upcall(coda_vcp(dentry->d_sb), insize, &outsize, inp);
Jan Harkes970648e2007-07-19 01:48:48 -0700560 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 sfs->f_blocks = outp->coda_statfs.stat.f_blocks;
562 sfs->f_bfree = outp->coda_statfs.stat.f_bfree;
563 sfs->f_bavail = outp->coda_statfs.stat.f_bavail;
564 sfs->f_files = outp->coda_statfs.stat.f_files;
565 sfs->f_ffree = outp->coda_statfs.stat.f_ffree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 }
567
Dan Carpenter936dae42019-07-16 16:28:41 -0700568 kvfree(inp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 return error;
570}
571
Pedro Cuadraa9fba242019-07-16 16:29:13 -0700572int venus_access_intent(struct super_block *sb, struct CodaFid *fid,
573 bool *access_intent_supported,
574 size_t count, loff_t ppos, int type)
575{
576 union inputArgs *inp;
577 union outputArgs *outp;
578 int insize, outsize, error;
579 bool finalizer =
580 type == CODA_ACCESS_TYPE_READ_FINISH ||
581 type == CODA_ACCESS_TYPE_WRITE_FINISH;
582
583 if (!*access_intent_supported && !finalizer)
584 return 0;
585
586 insize = SIZE(access_intent);
587 UPARG(CODA_ACCESS_INTENT);
588
589 inp->coda_access_intent.VFid = *fid;
590 inp->coda_access_intent.count = count;
591 inp->coda_access_intent.pos = ppos;
592 inp->coda_access_intent.type = type;
593
594 error = coda_upcall(coda_vcp(sb), insize,
595 finalizer ? NULL : &outsize, inp);
596
597 /*
598 * we have to free the request buffer for synchronous upcalls
599 * or when asynchronous upcalls fail, but not when asynchronous
600 * upcalls succeed
601 */
602 if (!finalizer || error)
603 kvfree(inp);
604
605 /* Chunked access is not supported or an old Coda client */
606 if (error == -EOPNOTSUPP) {
607 *access_intent_supported = false;
608 error = 0;
609 }
610 return error;
611}
612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613/*
614 * coda_upcall and coda_downcall routines.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 */
Al Viro5f47c7e2007-07-20 00:23:31 +0100616static void coda_block_signals(sigset_t *old)
Jan Harkesd9664c92007-07-19 01:48:46 -0700617{
618 spin_lock_irq(&current->sighand->siglock);
619 *old = current->blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Jan Harkesd9664c92007-07-19 01:48:46 -0700621 sigfillset(&current->blocked);
622 sigdelset(&current->blocked, SIGKILL);
623 sigdelset(&current->blocked, SIGSTOP);
624 sigdelset(&current->blocked, SIGINT);
625
626 recalc_sigpending();
627 spin_unlock_irq(&current->sighand->siglock);
628}
629
Al Viro5f47c7e2007-07-20 00:23:31 +0100630static void coda_unblock_signals(sigset_t *old)
Jan Harkesd9664c92007-07-19 01:48:46 -0700631{
632 spin_lock_irq(&current->sighand->siglock);
633 current->blocked = *old;
634 recalc_sigpending();
635 spin_unlock_irq(&current->sighand->siglock);
636}
637
638/* Don't allow signals to interrupt the following upcalls before venus
639 * has seen them,
640 * - CODA_CLOSE or CODA_RELEASE upcall (to avoid reference count problems)
641 * - CODA_STORE (to avoid data loss)
Pedro Cuadraa9fba242019-07-16 16:29:13 -0700642 * - CODA_ACCESS_INTENT (to avoid reference count problems)
Jan Harkesd9664c92007-07-19 01:48:46 -0700643 */
644#define CODA_INTERRUPTIBLE(r) (!coda_hard && \
645 (((r)->uc_opcode != CODA_CLOSE && \
646 (r)->uc_opcode != CODA_STORE && \
Pedro Cuadraa9fba242019-07-16 16:29:13 -0700647 (r)->uc_opcode != CODA_ACCESS_INTENT && \
Jan Harkesd9664c92007-07-19 01:48:46 -0700648 (r)->uc_opcode != CODA_RELEASE) || \
Jens Axboe4aeefdc2010-08-03 13:22:51 +0200649 (r)->uc_flags & CODA_REQ_READ))
Jan Harkesd9664c92007-07-19 01:48:46 -0700650
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400651static inline void coda_waitfor_upcall(struct venus_comm *vcp,
652 struct upc_req *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653{
654 DECLARE_WAITQUEUE(wait, current);
Jan Harkesd9664c92007-07-19 01:48:46 -0700655 unsigned long timeout = jiffies + coda_timeout * HZ;
656 sigset_t old;
657 int blocked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Al Viro5f47c7e2007-07-20 00:23:31 +0100659 coda_block_signals(&old);
Jan Harkesd9664c92007-07-19 01:48:46 -0700660 blocked = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Jan Harkesd9664c92007-07-19 01:48:46 -0700662 add_wait_queue(&req->uc_sleep, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 for (;;) {
Jan Harkesd9664c92007-07-19 01:48:46 -0700664 if (CODA_INTERRUPTIBLE(req))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 set_current_state(TASK_INTERRUPTIBLE);
666 else
667 set_current_state(TASK_UNINTERRUPTIBLE);
668
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 /* got a reply */
Jens Axboe4aeefdc2010-08-03 13:22:51 +0200670 if (req->uc_flags & (CODA_REQ_WRITE | CODA_REQ_ABORT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 break;
672
Jan Harkesd9664c92007-07-19 01:48:46 -0700673 if (blocked && time_after(jiffies, timeout) &&
674 CODA_INTERRUPTIBLE(req))
675 {
Al Viro5f47c7e2007-07-20 00:23:31 +0100676 coda_unblock_signals(&old);
Jan Harkesd9664c92007-07-19 01:48:46 -0700677 blocked = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Jan Harkesd9664c92007-07-19 01:48:46 -0700680 if (signal_pending(current)) {
681 list_del(&req->uc_chain);
682 break;
683 }
684
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400685 mutex_unlock(&vcp->vc_mutex);
Jan Harkesd9664c92007-07-19 01:48:46 -0700686 if (blocked)
687 schedule_timeout(HZ);
688 else
689 schedule();
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400690 mutex_lock(&vcp->vc_mutex);
Jan Harkesd9664c92007-07-19 01:48:46 -0700691 }
692 if (blocked)
Al Viro5f47c7e2007-07-20 00:23:31 +0100693 coda_unblock_signals(&old);
Jan Harkesd9664c92007-07-19 01:48:46 -0700694
695 remove_wait_queue(&req->uc_sleep, &wait);
696 set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697}
698
699
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700700/*
701 * coda_upcall will return an error in the case of
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 * failed communication with Venus _or_ will peek at Venus
703 * reply and return Venus' error.
704 *
705 * As venus has 2 types of errors, normal errors (positive) and internal
706 * errors (negative), normal errors are negated, while internal errors
707 * are all mapped to -EINTR, while showing a nice warning message. (jh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 */
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700709static int coda_upcall(struct venus_comm *vcp,
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700710 int inSize, int *outSize,
711 union inputArgs *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 union outputArgs *out;
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700714 union inputArgs *sig_inputArgs;
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400715 struct upc_req *req = NULL, *sig_req;
716 int error;
717
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400718 mutex_lock(&vcp->vc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700720 if (!vcp->vc_inuse) {
Fabian Frederickf38cfb252014-06-06 14:36:19 -0700721 pr_notice("Venus dead, not sending upcall\n");
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400722 error = -ENXIO;
723 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 }
725
726 /* Format the request message. */
Jan Harkes37461e12007-07-19 01:48:48 -0700727 req = kmalloc(sizeof(struct upc_req), GFP_KERNEL);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400728 if (!req) {
729 error = -ENOMEM;
730 goto exit;
731 }
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700732
Pedro Cuadraa9fba242019-07-16 16:29:13 -0700733 buffer->ih.unique = ++vcp->vc_seq;
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700734
Pedro Cuadraa9fba242019-07-16 16:29:13 -0700735 req->uc_data = (void *)buffer;
736 req->uc_flags = outSize ? 0 : CODA_REQ_ASYNC;
737 req->uc_inSize = inSize;
738 req->uc_outSize = (outSize && *outSize) ? *outSize : inSize;
739 req->uc_opcode = buffer->ih.opcode;
740 req->uc_unique = buffer->ih.unique;
741 init_waitqueue_head(&req->uc_sleep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
743 /* Append msg to pending queue and poke Venus. */
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700744 list_add_tail(&req->uc_chain, &vcp->vc_pending);
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700745 wake_up_interruptible(&vcp->vc_waitq);
Pedro Cuadraa9fba242019-07-16 16:29:13 -0700746
747 if (req->uc_flags & CODA_REQ_ASYNC) {
748 mutex_unlock(&vcp->vc_mutex);
749 return 0;
750 }
751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 /* We can be interrupted while we wait for Venus to process
753 * our request. If the interrupt occurs before Venus has read
754 * the request, we dequeue and return. If it occurs after the
755 * read but before the reply, we dequeue, send a signal
756 * message, and return. If it occurs after the reply we ignore
757 * it. In no case do we want to restart the syscall. If it
758 * was interrupted by a venus shutdown (psdev_close), return
759 * ENODEV. */
760
761 /* Go to sleep. Wake up on signals only after the timeout. */
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400762 coda_waitfor_upcall(vcp, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700764 /* Op went through, interrupt or not... */
Jens Axboe4aeefdc2010-08-03 13:22:51 +0200765 if (req->uc_flags & CODA_REQ_WRITE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 out = (union outputArgs *)req->uc_data;
767 /* here we map positive Venus errors to kernel errors */
768 error = -out->oh.result;
769 *outSize = req->uc_outSize;
770 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 }
772
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700773 error = -EINTR;
Jens Axboe4aeefdc2010-08-03 13:22:51 +0200774 if ((req->uc_flags & CODA_REQ_ABORT) || !signal_pending(current)) {
Fabian Frederickf38cfb252014-06-06 14:36:19 -0700775 pr_warn("Unexpected interruption.\n");
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700776 goto exit;
777 }
778
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700779 /* Interrupted before venus read it. */
Jens Axboe4aeefdc2010-08-03 13:22:51 +0200780 if (!(req->uc_flags & CODA_REQ_READ))
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700781 goto exit;
782
783 /* Venus saw the upcall, make sure we can send interrupt signal */
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700784 if (!vcp->vc_inuse) {
Fabian Frederickf38cfb252014-06-06 14:36:19 -0700785 pr_info("Venus dead, not sending signal.\n");
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700786 goto exit;
787 }
788
789 error = -ENOMEM;
Jan Harkes37461e12007-07-19 01:48:48 -0700790 sig_req = kmalloc(sizeof(struct upc_req), GFP_KERNEL);
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700791 if (!sig_req) goto exit;
792
Pedro Cuadraa9fba242019-07-16 16:29:13 -0700793 sig_inputArgs = kvzalloc(sizeof(struct coda_in_hdr), GFP_KERNEL);
794 if (!sig_inputArgs) {
Jan Harkes37461e12007-07-19 01:48:48 -0700795 kfree(sig_req);
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700796 goto exit;
797 }
798
799 error = -EINTR;
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700800 sig_inputArgs->ih.opcode = CODA_SIGNAL;
801 sig_inputArgs->ih.unique = req->uc_unique;
802
Jens Axboe4aeefdc2010-08-03 13:22:51 +0200803 sig_req->uc_flags = CODA_REQ_ASYNC;
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700804 sig_req->uc_opcode = sig_inputArgs->ih.opcode;
805 sig_req->uc_unique = sig_inputArgs->ih.unique;
Pedro Cuadraa9fba242019-07-16 16:29:13 -0700806 sig_req->uc_data = (void *)sig_inputArgs;
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700807 sig_req->uc_inSize = sizeof(struct coda_in_hdr);
808 sig_req->uc_outSize = sizeof(struct coda_in_hdr);
809
810 /* insert at head of queue! */
Jan Harkesa1b0aa82007-07-19 01:48:50 -0700811 list_add(&(sig_req->uc_chain), &vcp->vc_pending);
812 wake_up_interruptible(&vcp->vc_waitq);
Jan Harkesfe71b5f2007-07-19 01:48:46 -0700813
814exit:
Jan Harkes37461e12007-07-19 01:48:48 -0700815 kfree(req);
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400816 mutex_unlock(&vcp->vc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 return error;
818}
819
820/*
821 The statements below are part of the Coda opportunistic
822 programming -- taken from the Mach/BSD kernel code for Coda.
823 You don't get correct semantics by stating what needs to be
824 done without guaranteeing the invariants needed for it to happen.
825 When will be have time to find out what exactly is going on? (pjb)
826*/
827
828
829/*
830 * There are 7 cases where cache invalidations occur. The semantics
831 * of each is listed here:
832 *
833 * CODA_FLUSH -- flush all entries from the name cache and the cnode cache.
834 * CODA_PURGEUSER -- flush all entries from the name cache for a specific user
835 * This call is a result of token expiration.
836 *
837 * The next arise as the result of callbacks on a file or directory.
838 * CODA_ZAPFILE -- flush the cached attributes for a file.
839
840 * CODA_ZAPDIR -- flush the attributes for the dir and
841 * force a new lookup for all the children
842 of this dir.
843
844 *
845 * The next is a result of Venus detecting an inconsistent file.
846 * CODA_PURGEFID -- flush the attribute for the file
847 * purge it and its children from the dcache
848 *
849 * The last allows Venus to replace local fids with global ones
850 * during reintegration.
851 *
852 * CODA_REPLACE -- replace one CodaFid with another throughout the name cache */
853
Jan Harkes6e51f8a2019-07-16 16:28:16 -0700854int coda_downcall(struct venus_comm *vcp, int opcode, union outputArgs *out,
855 size_t nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856{
Jan Harkes5fd31e92007-07-19 01:48:49 -0700857 struct inode *inode = NULL;
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400858 struct CodaFid *fid = NULL, *newfid;
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400859 struct super_block *sb;
Jan Harkes5fd31e92007-07-19 01:48:49 -0700860
Jan Harkes6e51f8a2019-07-16 16:28:16 -0700861 /*
862 * Make sure we have received enough data from the cache
863 * manager to populate the necessary fields in the buffer
864 */
865 switch (opcode) {
866 case CODA_PURGEUSER:
867 if (nbytes < sizeof(struct coda_purgeuser_out))
868 return -EINVAL;
869 break;
870
871 case CODA_ZAPDIR:
872 if (nbytes < sizeof(struct coda_zapdir_out))
873 return -EINVAL;
874 break;
875
876 case CODA_ZAPFILE:
877 if (nbytes < sizeof(struct coda_zapfile_out))
878 return -EINVAL;
879 break;
880
881 case CODA_PURGEFID:
882 if (nbytes < sizeof(struct coda_purgefid_out))
883 return -EINVAL;
884 break;
885
886 case CODA_REPLACE:
887 if (nbytes < sizeof(struct coda_replace_out))
888 return -EINVAL;
889 break;
890 }
891
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 /* Handle invalidation requests. */
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400893 mutex_lock(&vcp->vc_mutex);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400894 sb = vcp->vc_sb;
895 if (!sb || !sb->s_root)
896 goto unlock_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
Jan Harkes5fd31e92007-07-19 01:48:49 -0700898 switch (opcode) {
899 case CODA_FLUSH:
900 coda_cache_clear_all(sb);
901 shrink_dcache_sb(sb);
David Howells2b0143b2015-03-17 22:25:59 +0000902 if (d_really_is_positive(sb->s_root))
903 coda_flag_inode(d_inode(sb->s_root), C_FLUSH);
Jan Harkes5fd31e92007-07-19 01:48:49 -0700904 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
Jan Harkes5fd31e92007-07-19 01:48:49 -0700906 case CODA_PURGEUSER:
907 coda_cache_clear_all(sb);
908 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
Jan Harkes5fd31e92007-07-19 01:48:49 -0700910 case CODA_ZAPDIR:
911 fid = &out->coda_zapdir.CodaFid;
Jan Harkes5fd31e92007-07-19 01:48:49 -0700912 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Jan Harkes5fd31e92007-07-19 01:48:49 -0700914 case CODA_ZAPFILE:
915 fid = &out->coda_zapfile.CodaFid;
Jan Harkes5fd31e92007-07-19 01:48:49 -0700916 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917
Jan Harkes5fd31e92007-07-19 01:48:49 -0700918 case CODA_PURGEFID:
919 fid = &out->coda_purgefid.CodaFid;
Jan Harkes5fd31e92007-07-19 01:48:49 -0700920 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
Jan Harkes5fd31e92007-07-19 01:48:49 -0700922 case CODA_REPLACE:
923 fid = &out->coda_replace.OldFid;
Jan Harkes5fd31e92007-07-19 01:48:49 -0700924 break;
925 }
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400926 if (fid)
927 inode = coda_fid_to_inode(fid, sb);
Jan Harkes5fd31e92007-07-19 01:48:49 -0700928
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400929unlock_out:
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400930 mutex_unlock(&vcp->vc_mutex);
Yoshihisa Abef7cc02b82010-10-25 02:03:45 -0400931
Yoshihisa Abeda47c192010-10-25 02:03:46 -0400932 if (!inode)
933 return 0;
934
935 switch (opcode) {
936 case CODA_ZAPDIR:
937 coda_flag_inode_children(inode, C_PURGE);
938 coda_flag_inode(inode, C_VATTR);
939 break;
940
941 case CODA_ZAPFILE:
942 coda_flag_inode(inode, C_VATTR);
943 break;
944
945 case CODA_PURGEFID:
946 coda_flag_inode_children(inode, C_PURGE);
947
948 /* catch the dentries later if some are still busy */
949 coda_flag_inode(inode, C_PURGE);
950 d_prune_aliases(inode);
951 break;
952
953 case CODA_REPLACE:
954 newfid = &out->coda_replace.NewFid;
955 coda_replace_fid(inode, fid, newfid);
956 break;
957 }
958 iput(inode);
Jan Harkes5fd31e92007-07-19 01:48:49 -0700959 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960}