Whamcloud - gitweb
Branch: HEAD
[fs/lustre-release.git] / libsysio / src / namei.c
1 /*
2  *    This Cplant(TM) source code is the property of Sandia National
3  *    Laboratories.
4  *
5  *    This Cplant(TM) source code is copyrighted by Sandia National
6  *    Laboratories.
7  *
8  *    The redistribution of this Cplant(TM) source code is subject to the
9  *    terms of the GNU Lesser General Public License
10  *    (see cit/LGPL or http://www.gnu.org/licenses/lgpl.html)
11  *
12  *    Cplant(TM) Copyright 1998-2003 Sandia Corporation. 
13  *    Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
14  *    license for use of this work by or on behalf of the US Government.
15  *    Export of this program may require a license from the United States
16  *    Government.
17  */
18
19 /*
20  * This library is free software; you can redistribute it and/or
21  * modify it under the terms of the GNU Lesser General Public
22  * License as published by the Free Software Foundation; either
23  * version 2.1 of the License, or (at your option) any later version.
24  * 
25  * This library is distributed in the hope that it will be useful,
26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
28  * Lesser General Public License for more details.
29  * 
30  * You should have received a copy of the GNU Lesser General Public
31  * License along with this library; if not, write to the Free Software
32  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33  *
34  * Questions or comments about this library should be sent to:
35  *
36  * Lee Ward
37  * Sandia National Laboratories, New Mexico
38  * P.O. Box 5800
39  * Albuquerque, NM 87185-1110
40  *
41  * lee@sandia.gov
42  */
43
44 #if defined(AUTOMOUNT_FILE_NAME) && defined(__linux__)
45 #define _BSD_SOURCE
46 #endif
47
48 #include <stdlib.h>
49 #include <string.h>
50 #include <errno.h>
51 #include <assert.h>
52 #include <unistd.h>
53 #include <sys/param.h>
54 #include <sys/types.h>
55 #include <sys/stat.h>
56 #include <sys/queue.h>
57
58 #include "sysio.h"
59 #include "mount.h"
60 #include "inode.h"
61
62 /*
63  * Parse next component in path.
64  */
65 #ifndef AUTOMOUNT_FILE_NAME
66 static
67 #endif
68 void
69 _sysio_next_component(const char *path, struct qstr *name)
70 {
71         while (*path == PATH_SEPARATOR)
72                 path++;
73         name->name = path;
74         name->len = 0;
75         name->hashval = 0;
76         while (*path && *path != PATH_SEPARATOR) {
77                 name->hashval =
78                     37 * name->hashval + *path++;
79                 name->len++;
80         }
81 }
82
83 /*
84  * Given parent, look up component.
85  */
86 static int
87 lookup(struct pnode *parent,
88        struct qstr *name,
89        struct pnode **pnop,
90        struct intent *intnt,
91        const char *path)
92 {
93         int     err;
94         struct pnode *pno;
95
96         if (!parent->p_base->pb_ino)
97                 return -ENOTDIR;
98
99         err = _sysio_permitted(parent->p_base->pb_ino, X_OK);
100         if (err)
101                 return err;
102
103         /*
104          * Short-circuit `.' and `..'; We don't cache those.
105          */
106         pno = NULL;
107         if (name->len == 1 && name->name[0] == '.')
108                 pno = parent;
109         else if (name->len == 2 && name->name[0] == '.' && name->name[1] == '.')
110                 pno = parent->p_parent;
111         if (pno)
112                 P_REF(pno);
113         else {
114                 /*
115                  * Get cache entry then.
116                  */
117                 err = _sysio_p_find_alias(parent, name, &pno);
118                 if (err)
119                         return err;
120         }
121
122         /*
123          * While covered, move to the covering node.
124          */
125         while (pno->p_cover && pno->p_cover != pno) {
126                 struct pnode *cover;
127
128                 cover = pno->p_cover;
129                 P_REF(cover);
130                 P_RELE(pno);
131                 pno = cover;
132         }
133
134         *pnop = pno;
135
136         /*
137          * (Re)validate the pnode.
138          */
139         err = _sysio_p_validate(pno, intnt, path);
140         if (err)
141                 return err;
142
143         return 0;
144 }
145
146 /*
147  * The meat. Walk an absolute or relative path, looking up each
148  * component. Various flags in the nameidata argument govern actions
149  * and return values/state. They are:
150  *
151  * ND_NOFOLLOW          symbolic links are not followed
152  * ND_NEGOK             if terminal/leaf does not exist, return
153  *                       path node (alias) anyway.
154  */
155 int
156 _sysio_path_walk(struct pnode *parent, struct nameidata *nd)
157 {
158         int     err;
159         const char *path;
160         struct qstr this, next;
161         struct inode *ino;
162
163         /*
164          * NULL path?
165          */
166         if (!nd->nd_path)
167                 return -EFAULT;
168
169         /*
170          * Empty path?
171          */
172         if (!*nd->nd_path)
173                 return -ENOENT;
174
175         /*
176          * Leading slash?
177          */
178         if (*nd->nd_path == PATH_SEPARATOR) {
179                 /*
180                  * Make parent the root of the name space.
181                  */
182                 parent = nd->nd_root;
183         }
184
185 #if DEFER_INIT_CWD
186         if (!parent) {
187                 const char *icwd;
188
189                 if (!_sysio_init_cwd)
190                         abort();
191
192                 /*
193                  * Finally have to set the curretn working directory. We can
194                  * not tolerate errors here or else risk leaving the process
195                  * in a very unexpected location. We abort then unless all goes
196                  * well.
197                  */
198                 icwd = _sysio_init_cwd;
199                 _sysio_init_cwd = NULL;
200                 if (_sysio_namei(NULL, icwd, 0, NULL, &parent) != 0 ||
201                     _sysio_p_chdir(parent) != 0)
202                         abort();
203         }
204 #endif
205
206         /*
207          * (Re)Validate the parent.
208          */
209         err = _sysio_p_validate(parent, NULL, NULL);
210         if (err)
211                 return err;
212
213         /*
214          * Prime everything for the loop. Will need another reference to the
215          * initial directory. It'll be dropped later.
216          */
217         nd->nd_pno = parent;
218         P_REF(nd->nd_pno);
219         _sysio_next_component(nd->nd_path, &next);
220         path = next.name;
221         parent = NULL;
222         err = 0;
223
224         /*
225          * Derecurse the path tree-walk.
226          */
227         for (;;) {
228                 ino = nd->nd_pno->p_base->pb_ino;
229                 if (S_ISLNK(ino->i_stbuf.st_mode) &&
230                     (next.len || !(nd->nd_flags & ND_NOFOLLOW))) {
231                         char    *lpath;
232                         ssize_t cc;
233                         struct nameidata nameidata;
234
235                         if (nd->nd_slicnt >= MAX_SYMLINK) {
236                                 err = -ELOOP;
237                                 break;
238                         }
239
240                         /*
241                          * Follow symbolic link.
242                          */
243                         lpath = malloc(MAXPATHLEN + 1);
244                         if (!lpath) {
245                                 err = -ENOMEM;
246                                 break;
247                         }
248                         cc =
249                             ino->i_ops.inop_readlink(nd->nd_pno,
250                                                      lpath,
251                                                      MAXPATHLEN);
252                         if (cc < 0) {
253                                 free(lpath);
254                                 err = (int )cc;
255                                 break;
256                         }
257                         lpath[cc] = '\0';                       /* NUL term */
258                         /*
259                          * Handle symbolic links with recursion. Yuck!
260                          */
261                         ND_INIT(&nameidata,
262                                 (nd->nd_flags | ND_NEGOK),
263                                 lpath,
264                                 nd->nd_root,
265                                 nd->nd_intent);
266                         nameidata.nd_slicnt = nd->nd_slicnt + 1;
267                         err =
268                             _sysio_path_walk(nd->nd_pno->p_parent, &nameidata);
269                         free(lpath);
270                         if (err)
271                                 break;
272                         P_RELE(nd->nd_pno);
273                         nd->nd_pno = nameidata.nd_pno;
274                         ino = nd->nd_pno->p_base->pb_ino;
275                 }
276 #ifdef AUTOMOUNT_FILE_NAME
277                 else if (ino &&
278                          S_ISDIR(ino->i_stbuf.st_mode) &&
279                          (nd->nd_pno->p_mount->mnt_flags & MOUNT_F_AUTO) &&
280                          nd->nd_amcnt < MAX_MOUNT_DEPTH &&
281                          ino->i_stbuf.st_mode & S_ISUID) {
282                         struct pnode *pno;
283
284                         /*
285                          * We're committed to a lookup. It's time to see if
286                          * we're going to do it in an automount-point and
287                          * arrange the mount if so.
288                          */
289                         assert(!nd->nd_pno->p_cover);
290                         err =
291                             lookup(nd->nd_pno,
292                                    &_sysio_mount_file_name,
293                                    &pno,
294                                    NULL,
295                                    NULL);
296                         if (pno)
297                                 P_RELE(pno);
298                         if (!err && _sysio_automount(pno) == 0) {
299                                 struct pnode *root;
300
301                                 /*
302                                  * All went well. Need to switch
303                                  * parent pno and ino to the
304                                  * root of the newly mounted sub-tree.
305                                  *
306                                  * NB:
307                                  * We don't recurseively retry these
308                                  * things. It's OK to have the new root
309                                  * be an automount-point but it's going
310                                  * to take another lookup to accomplish it.
311                                  * The alternative could get us into an
312                                  * infinite loop.
313                                  */
314                                 root = nd->nd_pno->p_cover;
315                                 assert(root);
316                                 P_RELE(nd->nd_pno);
317                                 nd->nd_pno = root;
318 #if 0
319                                 P_REF(nd->nd_pno);
320 #endif
321                                 ino = nd->nd_pno->p_base->pb_ino;
322                                 assert(ino);
323
324                                 /*
325                                  * Must send the intent-path again.
326                                  */
327                                 path = nd->nd_path;
328                                 nd->nd_amcnt++;
329
330                                 /*
331                                  * Must go back top and retry with this
332                                  * new pnode as parent.
333                                  */
334                                 continue;
335                         }
336                         err = 0;                        /* it never happened */
337                 }
338 #endif
339
340                 /*
341                  * Set up for next component.
342                  */
343                 this = next;
344                 if (path)
345                         path = this.name;
346                 if (!this.len)
347                         break;
348                 if (!ino) {
349                         /*
350                          * Should only be here if final component was
351                          * target of a symlink.
352                          */
353                         nd->nd_path = this.name + this.len;
354                         err = -ENOENT;
355                         break;
356                 }
357                 nd->nd_path = this.name + this.len;
358                 _sysio_next_component(nd->nd_path, &next);
359                 parent = nd->nd_pno;
360                 nd->nd_pno = NULL;
361
362                 /*
363                  * Parent must be a directory.
364                  */
365                 if (ino && !S_ISDIR(ino->i_stbuf.st_mode)) {
366                         err = -ENOTDIR;
367                         break;
368                 }
369
370                 /*
371                  * The extra path arg is passed only on the first lookup in the
372                  * walk as we cross into each file system, anew. The intent is
373                  * passed both on the first lookup and when trying to look up
374                  * the final component -- Of the original path, not on the
375                  * file system.
376                  *
377                  * Confused? Me too and I came up with this weirdness. It's
378                  * hints to the file system drivers. Read on.
379                  *
380                  * The first lookup will give everything one needs to ready
381                  * everything for the entire operation before the path is
382                  * walked. The file system driver knows it's the first lookup
383                  * in the walk because it has both the path and the intent.
384                  *
385                  * Alternatively, one could split the duties; The first lookup
386                  * can be used to prime the file system inode cache with the
387                  * interior nodes we'll want in the path-walk. Then, when
388                  * looking up the last component, ready everything for the
389                  * operations(s) to come. The file system driver knows it's
390                  * the last lookup in the walk because it has the intent,
391                  * again, but without the path.
392                  *
393                  * One special case; If we were asked to look up a single
394                  * component, we treat it as the last component. The file
395                  * system driver never sees the extra path argument. It should
396                  * be noted that the driver always has the fully qualified
397                  * path, on the target file system, available to it for any
398                  * node it is looking up, including the last, via the base
399                  * path node and it's ancestor chain.
400                  */
401                 err =
402                     lookup(parent,
403                            &this,
404                            &nd->nd_pno,
405                            (path || !next.len)
406                              ? nd->nd_intent
407                              : NULL,
408                            (path && next.len) ? path : NULL);
409                 if (err) {
410                         if (err == -ENOENT &&
411                             !next.len &&
412                             (nd->nd_flags & ND_NEGOK))
413                                 err = 0;
414                         break;
415                 }
416                 path = NULL;                            /* Stop that! */
417                 if ((parent->p_mount->mnt_fs !=
418                      nd->nd_pno->p_mount->mnt_fs)) {
419                         /*
420                          * Crossed into a new fs. We'll want the next lookup
421                          * to include the path again.
422                          */
423                         path = nd->nd_path;
424                 }
425
426                 /*
427                  * Release the parent.
428                  */
429                 P_RELE(parent);
430                 parent = NULL;
431         }
432
433         /*
434          * Trailing separators cause us to break from the loop with
435          * a parent set but no pnode. Check for that.
436          */
437         if (!nd->nd_pno) {
438                 nd->nd_pno = parent;
439                 parent = NULL;
440                 /*
441                  * Make sure the last processed component was a directory. The
442                  * trailing slashes are illegal behind anything else.
443                  */
444                 if (!(err ||
445                       S_ISDIR(nd->nd_pno->p_base->pb_ino->i_stbuf.st_mode)))
446                         err = -ENOTDIR;
447         }
448
449         /*
450          * Drop reference to parent if set. Either we have a dup of the original
451          * parent or an intermediate reference.
452          */
453         if (parent)
454                 P_RELE(parent);
455
456         /*
457          * On error, we will want to drop our reference to the current
458          * path node if at end.
459          */
460         if (err && nd->nd_pno) {
461                 P_RELE(nd->nd_pno);
462                 nd->nd_pno = NULL;
463         }
464
465         return err;
466 }
467
468 #ifdef CPLANT_YOD
469 /* 
470  * for backward compatibility w/protocol switch
471  * remove everything up to the first ':'
472  * fortran libs prepend cwd to path, so not much choice
473  */
474 #define STRIP_PREFIX(p) strchr(p,':') ? strchr(p,':')+1 : p
475 #else
476 #define STRIP_PREFIX(p) p
477 #endif
478
479 /*
480  * Expanded form of the path-walk routine, with the common arguments, builds
481  * the nameidata bundle and calls path-walk.
482  */
483 int
484 _sysio_namei(struct pnode *parent,
485              const char *path,
486              unsigned flags,
487              struct intent *intnt,
488              struct pnode **pnop)
489 {
490         struct nameidata nameidata;
491         int     err;
492
493         ND_INIT(&nameidata, flags, STRIP_PREFIX(path), _sysio_root, intnt);
494         err = _sysio_path_walk(parent, &nameidata);
495         if (!err)
496                 *pnop = nameidata.nd_pno;
497         return err;
498 }