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