rxrpc: do not pull udp headers on receive
[cascardo/linux.git] / fs / orangefs / namei.c
1 /*
2  * (C) 2001 Clemson University and The University of Chicago
3  *
4  * See COPYING in top-level directory.
5  */
6
7 /*
8  *  Linux VFS namei operations.
9  */
10
11 #include "protocol.h"
12 #include "orangefs-kernel.h"
13
14 /*
15  * Get a newly allocated inode to go with a negative dentry.
16  */
17 static int orangefs_create(struct inode *dir,
18                         struct dentry *dentry,
19                         umode_t mode,
20                         bool exclusive)
21 {
22         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
23         struct orangefs_kernel_op_s *new_op;
24         struct inode *inode;
25         int ret;
26
27         gossip_debug(GOSSIP_NAME_DEBUG, "%s: %s\n",
28                      __func__,
29                      dentry->d_name.name);
30
31         new_op = op_alloc(ORANGEFS_VFS_OP_CREATE);
32         if (!new_op)
33                 return -ENOMEM;
34
35         new_op->upcall.req.create.parent_refn = parent->refn;
36
37         fill_default_sys_attrs(new_op->upcall.req.create.attributes,
38                                ORANGEFS_TYPE_METAFILE, mode);
39
40         strncpy(new_op->upcall.req.create.d_name,
41                 dentry->d_name.name, ORANGEFS_NAME_MAX);
42
43         ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
44
45         gossip_debug(GOSSIP_NAME_DEBUG,
46                      "%s: %s: handle:%pU: fsid:%d: new_op:%p: ret:%d:\n",
47                      __func__,
48                      dentry->d_name.name,
49                      &new_op->downcall.resp.create.refn.khandle,
50                      new_op->downcall.resp.create.refn.fs_id,
51                      new_op,
52                      ret);
53
54         if (ret < 0)
55                 goto out;
56
57         inode = orangefs_new_inode(dir->i_sb, dir, S_IFREG | mode, 0,
58                                 &new_op->downcall.resp.create.refn);
59         if (IS_ERR(inode)) {
60                 gossip_err("%s: Failed to allocate inode for file :%s:\n",
61                            __func__,
62                            dentry->d_name.name);
63                 ret = PTR_ERR(inode);
64                 goto out;
65         }
66
67         gossip_debug(GOSSIP_NAME_DEBUG,
68                      "%s: Assigned inode :%pU: for file :%s:\n",
69                      __func__,
70                      get_khandle_from_ino(inode),
71                      dentry->d_name.name);
72
73         d_instantiate(dentry, inode);
74         unlock_new_inode(inode);
75
76         gossip_debug(GOSSIP_NAME_DEBUG,
77                      "%s: dentry instantiated for %s\n",
78                      __func__,
79                      dentry->d_name.name);
80
81         SetMtimeFlag(parent);
82         dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
83         mark_inode_dirty_sync(dir);
84         ret = 0;
85 out:
86         op_release(new_op);
87         gossip_debug(GOSSIP_NAME_DEBUG,
88                      "%s: %s: returning %d\n",
89                      __func__,
90                      dentry->d_name.name,
91                      ret);
92         return ret;
93 }
94
95 /*
96  * Attempt to resolve an object name (dentry->d_name), parent handle, and
97  * fsid into a handle for the object.
98  */
99 static struct dentry *orangefs_lookup(struct inode *dir, struct dentry *dentry,
100                                    unsigned int flags)
101 {
102         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
103         struct orangefs_kernel_op_s *new_op;
104         struct inode *inode;
105         struct dentry *res;
106         int ret = -EINVAL;
107
108         /*
109          * in theory we could skip a lookup here (if the intent is to
110          * create) in order to avoid a potentially failed lookup, but
111          * leaving it in can skip a valid lookup and try to create a file
112          * that already exists (e.g. the vfs already handles checking for
113          * -EEXIST on O_EXCL opens, which is broken if we skip this lookup
114          * in the create path)
115          */
116         gossip_debug(GOSSIP_NAME_DEBUG, "%s called on %s\n",
117                      __func__, dentry->d_name.name);
118
119         if (dentry->d_name.len > (ORANGEFS_NAME_MAX - 1))
120                 return ERR_PTR(-ENAMETOOLONG);
121
122         new_op = op_alloc(ORANGEFS_VFS_OP_LOOKUP);
123         if (!new_op)
124                 return ERR_PTR(-ENOMEM);
125
126         new_op->upcall.req.lookup.sym_follow = ORANGEFS_LOOKUP_LINK_NO_FOLLOW;
127
128         gossip_debug(GOSSIP_NAME_DEBUG, "%s:%s:%d using parent %pU\n",
129                      __FILE__,
130                      __func__,
131                      __LINE__,
132                      &parent->refn.khandle);
133         new_op->upcall.req.lookup.parent_refn = parent->refn;
134
135         strncpy(new_op->upcall.req.lookup.d_name, dentry->d_name.name,
136                 ORANGEFS_NAME_MAX);
137
138         gossip_debug(GOSSIP_NAME_DEBUG,
139                      "%s: doing lookup on %s under %pU,%d\n",
140                      __func__,
141                      new_op->upcall.req.lookup.d_name,
142                      &new_op->upcall.req.lookup.parent_refn.khandle,
143                      new_op->upcall.req.lookup.parent_refn.fs_id);
144
145         ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
146
147         gossip_debug(GOSSIP_NAME_DEBUG,
148                      "Lookup Got %pU, fsid %d (ret=%d)\n",
149                      &new_op->downcall.resp.lookup.refn.khandle,
150                      new_op->downcall.resp.lookup.refn.fs_id,
151                      ret);
152
153         if (ret < 0) {
154                 if (ret == -ENOENT) {
155                         /*
156                          * if no inode was found, add a negative dentry to
157                          * dcache anyway; if we don't, we don't hold expected
158                          * lookup semantics and we most noticeably break
159                          * during directory renames.
160                          *
161                          * however, if the operation failed or exited, do not
162                          * add the dentry (e.g. in the case that a touch is
163                          * issued on a file that already exists that was
164                          * interrupted during this lookup -- no need to add
165                          * another negative dentry for an existing file)
166                          */
167
168                         gossip_debug(GOSSIP_NAME_DEBUG,
169                                      "orangefs_lookup: Adding *negative* dentry "
170                                      "%p for %s\n",
171                                      dentry,
172                                      dentry->d_name.name);
173
174                         d_add(dentry, NULL);
175                         res = NULL;
176                         goto out;
177                 }
178
179                 /* must be a non-recoverable error */
180                 res = ERR_PTR(ret);
181                 goto out;
182         }
183
184         inode = orangefs_iget(dir->i_sb, &new_op->downcall.resp.lookup.refn);
185         if (IS_ERR(inode)) {
186                 gossip_debug(GOSSIP_NAME_DEBUG,
187                         "error %ld from iget\n", PTR_ERR(inode));
188                 res = ERR_CAST(inode);
189                 goto out;
190         }
191
192         gossip_debug(GOSSIP_NAME_DEBUG,
193                      "%s:%s:%d "
194                      "Found good inode [%lu] with count [%d]\n",
195                      __FILE__,
196                      __func__,
197                      __LINE__,
198                      inode->i_ino,
199                      (int)atomic_read(&inode->i_count));
200
201         /* update dentry/inode pair into dcache */
202         res = d_splice_alias(inode, dentry);
203
204         gossip_debug(GOSSIP_NAME_DEBUG,
205                      "Lookup success (inode ct = %d)\n",
206                      (int)atomic_read(&inode->i_count));
207 out:
208         op_release(new_op);
209         return res;
210 }
211
212 /* return 0 on success; non-zero otherwise */
213 static int orangefs_unlink(struct inode *dir, struct dentry *dentry)
214 {
215         struct inode *inode = dentry->d_inode;
216         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
217         struct orangefs_kernel_op_s *new_op;
218         int ret;
219
220         gossip_debug(GOSSIP_NAME_DEBUG,
221                      "%s: called on %s\n"
222                      "  (inode %pU): Parent is %pU | fs_id %d\n",
223                      __func__,
224                      dentry->d_name.name,
225                      get_khandle_from_ino(inode),
226                      &parent->refn.khandle,
227                      parent->refn.fs_id);
228
229         new_op = op_alloc(ORANGEFS_VFS_OP_REMOVE);
230         if (!new_op)
231                 return -ENOMEM;
232
233         new_op->upcall.req.remove.parent_refn = parent->refn;
234         strncpy(new_op->upcall.req.remove.d_name, dentry->d_name.name,
235                 ORANGEFS_NAME_MAX);
236
237         ret = service_operation(new_op, "orangefs_unlink",
238                                 get_interruptible_flag(inode));
239
240         gossip_debug(GOSSIP_NAME_DEBUG,
241                      "%s: service_operation returned:%d:\n",
242                      __func__,
243                      ret);
244
245         op_release(new_op);
246
247         if (!ret) {
248                 drop_nlink(inode);
249
250                 SetMtimeFlag(parent);
251                 dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
252                 mark_inode_dirty_sync(dir);
253         }
254         return ret;
255 }
256
257 static int orangefs_symlink(struct inode *dir,
258                          struct dentry *dentry,
259                          const char *symname)
260 {
261         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
262         struct orangefs_kernel_op_s *new_op;
263         struct inode *inode;
264         int mode = 755;
265         int ret;
266
267         gossip_debug(GOSSIP_NAME_DEBUG, "%s: called\n", __func__);
268
269         if (!symname)
270                 return -EINVAL;
271
272         if (strlen(symname)+1 > ORANGEFS_NAME_MAX)
273                 return -ENAMETOOLONG;
274
275         new_op = op_alloc(ORANGEFS_VFS_OP_SYMLINK);
276         if (!new_op)
277                 return -ENOMEM;
278
279         new_op->upcall.req.sym.parent_refn = parent->refn;
280
281         fill_default_sys_attrs(new_op->upcall.req.sym.attributes,
282                                ORANGEFS_TYPE_SYMLINK,
283                                mode);
284
285         strncpy(new_op->upcall.req.sym.entry_name,
286                 dentry->d_name.name,
287                 ORANGEFS_NAME_MAX);
288         strncpy(new_op->upcall.req.sym.target, symname, ORANGEFS_NAME_MAX);
289
290         ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
291
292         gossip_debug(GOSSIP_NAME_DEBUG,
293                      "Symlink Got ORANGEFS handle %pU on fsid %d (ret=%d)\n",
294                      &new_op->downcall.resp.sym.refn.khandle,
295                      new_op->downcall.resp.sym.refn.fs_id, ret);
296
297         if (ret < 0) {
298                 gossip_debug(GOSSIP_NAME_DEBUG,
299                             "%s: failed with error code %d\n",
300                             __func__, ret);
301                 goto out;
302         }
303
304         inode = orangefs_new_inode(dir->i_sb, dir, S_IFLNK | mode, 0,
305                                 &new_op->downcall.resp.sym.refn);
306         if (IS_ERR(inode)) {
307                 gossip_err
308                     ("*** Failed to allocate orangefs symlink inode\n");
309                 ret = PTR_ERR(inode);
310                 goto out;
311         }
312
313         gossip_debug(GOSSIP_NAME_DEBUG,
314                      "Assigned symlink inode new number of %pU\n",
315                      get_khandle_from_ino(inode));
316
317         d_instantiate(dentry, inode);
318         unlock_new_inode(inode);
319
320         gossip_debug(GOSSIP_NAME_DEBUG,
321                      "Inode (Symlink) %pU -> %s\n",
322                      get_khandle_from_ino(inode),
323                      dentry->d_name.name);
324
325         SetMtimeFlag(parent);
326         dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
327         mark_inode_dirty_sync(dir);
328         ret = 0;
329 out:
330         op_release(new_op);
331         return ret;
332 }
333
334 static int orangefs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
335 {
336         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
337         struct orangefs_kernel_op_s *new_op;
338         struct inode *inode;
339         int ret;
340
341         new_op = op_alloc(ORANGEFS_VFS_OP_MKDIR);
342         if (!new_op)
343                 return -ENOMEM;
344
345         new_op->upcall.req.mkdir.parent_refn = parent->refn;
346
347         fill_default_sys_attrs(new_op->upcall.req.mkdir.attributes,
348                               ORANGEFS_TYPE_DIRECTORY, mode);
349
350         strncpy(new_op->upcall.req.mkdir.d_name,
351                 dentry->d_name.name, ORANGEFS_NAME_MAX);
352
353         ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
354
355         gossip_debug(GOSSIP_NAME_DEBUG,
356                      "Mkdir Got ORANGEFS handle %pU on fsid %d\n",
357                      &new_op->downcall.resp.mkdir.refn.khandle,
358                      new_op->downcall.resp.mkdir.refn.fs_id);
359
360         if (ret < 0) {
361                 gossip_debug(GOSSIP_NAME_DEBUG,
362                              "%s: failed with error code %d\n",
363                              __func__, ret);
364                 goto out;
365         }
366
367         inode = orangefs_new_inode(dir->i_sb, dir, S_IFDIR | mode, 0,
368                                 &new_op->downcall.resp.mkdir.refn);
369         if (IS_ERR(inode)) {
370                 gossip_err("*** Failed to allocate orangefs dir inode\n");
371                 ret = PTR_ERR(inode);
372                 goto out;
373         }
374
375         gossip_debug(GOSSIP_NAME_DEBUG,
376                      "Assigned dir inode new number of %pU\n",
377                      get_khandle_from_ino(inode));
378
379         d_instantiate(dentry, inode);
380         unlock_new_inode(inode);
381
382         gossip_debug(GOSSIP_NAME_DEBUG,
383                      "Inode (Directory) %pU -> %s\n",
384                      get_khandle_from_ino(inode),
385                      dentry->d_name.name);
386
387         /*
388          * NOTE: we have no good way to keep nlink consistent for directories
389          * across clients; keep constant at 1.
390          */
391         SetMtimeFlag(parent);
392         dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
393         mark_inode_dirty_sync(dir);
394 out:
395         op_release(new_op);
396         return ret;
397 }
398
399 static int orangefs_rename(struct inode *old_dir,
400                         struct dentry *old_dentry,
401                         struct inode *new_dir,
402                         struct dentry *new_dentry)
403 {
404         struct orangefs_kernel_op_s *new_op;
405         int ret;
406
407         gossip_debug(GOSSIP_NAME_DEBUG,
408                      "orangefs_rename: called (%s/%s => %s/%s) ct=%d\n",
409                      old_dentry->d_parent->d_name.name,
410                      old_dentry->d_name.name,
411                      new_dentry->d_parent->d_name.name,
412                      new_dentry->d_name.name,
413                      d_count(new_dentry));
414
415         new_op = op_alloc(ORANGEFS_VFS_OP_RENAME);
416         if (!new_op)
417                 return -EINVAL;
418
419         new_op->upcall.req.rename.old_parent_refn = ORANGEFS_I(old_dir)->refn;
420         new_op->upcall.req.rename.new_parent_refn = ORANGEFS_I(new_dir)->refn;
421
422         strncpy(new_op->upcall.req.rename.d_old_name,
423                 old_dentry->d_name.name,
424                 ORANGEFS_NAME_MAX);
425         strncpy(new_op->upcall.req.rename.d_new_name,
426                 new_dentry->d_name.name,
427                 ORANGEFS_NAME_MAX);
428
429         ret = service_operation(new_op,
430                                 "orangefs_rename",
431                                 get_interruptible_flag(old_dentry->d_inode));
432
433         gossip_debug(GOSSIP_NAME_DEBUG,
434                      "orangefs_rename: got downcall status %d\n",
435                      ret);
436
437         if (new_dentry->d_inode)
438                 new_dentry->d_inode->i_ctime = CURRENT_TIME;
439
440         op_release(new_op);
441         return ret;
442 }
443
444 /* ORANGEFS implementation of VFS inode operations for directories */
445 struct inode_operations orangefs_dir_inode_operations = {
446         .lookup = orangefs_lookup,
447         .get_acl = orangefs_get_acl,
448         .set_acl = orangefs_set_acl,
449         .create = orangefs_create,
450         .unlink = orangefs_unlink,
451         .symlink = orangefs_symlink,
452         .mkdir = orangefs_mkdir,
453         .rmdir = orangefs_unlink,
454         .rename = orangefs_rename,
455         .setattr = orangefs_setattr,
456         .getattr = orangefs_getattr,
457         .setxattr = generic_setxattr,
458         .getxattr = generic_getxattr,
459         .removexattr = generic_removexattr,
460         .listxattr = orangefs_listxattr,
461         .permission = orangefs_permission,
462 };