~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/freevxfs/vxfs_lookup.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 2000-2001 Christoph Hellwig.
  3  * Copyright (c) 2016 Krzysztof Blaszkowski
  4  * All rights reserved.
  5  *
  6  * Redistribution and use in source and binary forms, with or without
  7  * modification, are permitted provided that the following conditions
  8  * are met:
  9  * 1. Redistributions of source code must retain the above copyright
 10  *    notice, this list of conditions, and the following disclaimer,
 11  *    without modification.
 12  * 2. The name of the author may not be used to endorse or promote products
 13  *    derived from this software without specific prior written permission.
 14  *
 15  * Alternatively, this software may be distributed under the terms of the
 16  * GNU General Public License ("GPL").
 17  *
 18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
 22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 28  * SUCH DAMAGE.
 29  */
 30 
 31 /*
 32  * Veritas filesystem driver - lookup and other directory related code.
 33  */
 34 #include <linux/fs.h>
 35 #include <linux/time.h>
 36 #include <linux/mm.h>
 37 #include <linux/highmem.h>
 38 #include <linux/kernel.h>
 39 #include <linux/pagemap.h>
 40 
 41 #include "vxfs.h"
 42 #include "vxfs_dir.h"
 43 #include "vxfs_inode.h"
 44 #include "vxfs_extern.h"
 45 
 46 /*
 47  * Number of VxFS blocks per page.
 48  */
 49 #define VXFS_BLOCK_PER_PAGE(sbp)  ((PAGE_SIZE / (sbp)->s_blocksize))
 50 
 51 
 52 static struct dentry *  vxfs_lookup(struct inode *, struct dentry *, unsigned int);
 53 static int              vxfs_readdir(struct file *, struct dir_context *);
 54 
 55 const struct inode_operations vxfs_dir_inode_ops = {
 56         .lookup =               vxfs_lookup,
 57 };
 58 
 59 const struct file_operations vxfs_dir_operations = {
 60         .llseek =               generic_file_llseek,
 61         .read =                 generic_read_dir,
 62         .iterate_shared =       vxfs_readdir,
 63 };
 64 
 65 
 66 /**
 67  * vxfs_find_entry - find a mathing directory entry for a dentry
 68  * @ip:         directory inode
 69  * @dp:         dentry for which we want to find a direct
 70  * @ppp:        gets filled with the page the return value sits in
 71  *
 72  * Description:
 73  *   vxfs_find_entry finds a &struct vxfs_direct for the VFS directory
 74  *   cache entry @dp.  @ppp will be filled with the page the return
 75  *   value resides in.
 76  *
 77  * Returns:
 78  *   The wanted direct on success, else a NULL pointer.
 79  */
 80 static struct vxfs_direct *
 81 vxfs_find_entry(struct inode *ip, struct dentry *dp, struct page **ppp)
 82 {
 83         u_long bsize = ip->i_sb->s_blocksize;
 84         const char *name = dp->d_name.name;
 85         int namelen = dp->d_name.len;
 86         loff_t limit = VXFS_DIRROUND(ip->i_size);
 87         struct vxfs_direct *de_exit = NULL;
 88         loff_t pos = 0;
 89         struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb);
 90 
 91         while (pos < limit) {
 92                 struct page *pp;
 93                 char *kaddr;
 94                 int pg_ofs = pos & ~PAGE_MASK;
 95 
 96                 pp = vxfs_get_page(ip->i_mapping, pos >> PAGE_SHIFT);
 97                 if (IS_ERR(pp))
 98                         return NULL;
 99                 kaddr = (char *)page_address(pp);
100 
101                 while (pg_ofs < PAGE_SIZE && pos < limit) {
102                         struct vxfs_direct *de;
103 
104                         if ((pos & (bsize - 1)) < 4) {
105                                 struct vxfs_dirblk *dbp =
106                                         (struct vxfs_dirblk *)
107                                          (kaddr + (pos & ~PAGE_MASK));
108                                 int overhead = VXFS_DIRBLKOV(sbi, dbp);
109 
110                                 pos += overhead;
111                                 pg_ofs += overhead;
112                         }
113                         de = (struct vxfs_direct *)(kaddr + pg_ofs);
114 
115                         if (!de->d_reclen) {
116                                 pos += bsize - 1;
117                                 pos &= ~(bsize - 1);
118                                 break;
119                         }
120 
121                         pg_ofs += fs16_to_cpu(sbi, de->d_reclen);
122                         pos += fs16_to_cpu(sbi, de->d_reclen);
123                         if (!de->d_ino)
124                                 continue;
125 
126                         if (namelen != fs16_to_cpu(sbi, de->d_namelen))
127                                 continue;
128                         if (!memcmp(name, de->d_name, namelen)) {
129                                 *ppp = pp;
130                                 de_exit = de;
131                                 break;
132                         }
133                 }
134                 if (!de_exit)
135                         vxfs_put_page(pp);
136                 else
137                         break;
138         }
139 
140         return de_exit;
141 }
142 
143 /**
144  * vxfs_inode_by_name - find inode number for dentry
145  * @dip:        directory to search in
146  * @dp:         dentry we search for
147  *
148  * Description:
149  *   vxfs_inode_by_name finds out the inode number of
150  *   the path component described by @dp in @dip.
151  *
152  * Returns:
153  *   The wanted inode number on success, else Zero.
154  */
155 static ino_t
156 vxfs_inode_by_name(struct inode *dip, struct dentry *dp)
157 {
158         struct vxfs_direct              *de;
159         struct page                     *pp;
160         ino_t                           ino = 0;
161 
162         de = vxfs_find_entry(dip, dp, &pp);
163         if (de) {
164                 ino = fs32_to_cpu(VXFS_SBI(dip->i_sb), de->d_ino);
165                 kunmap(pp);
166                 put_page(pp);
167         }
168         
169         return (ino);
170 }
171 
172 /**
173  * vxfs_lookup - lookup pathname component
174  * @dip:        dir in which we lookup
175  * @dp:         dentry we lookup
176  * @flags:      lookup flags
177  *
178  * Description:
179  *   vxfs_lookup tries to lookup the pathname component described
180  *   by @dp in @dip.
181  *
182  * Returns:
183  *   A NULL-pointer on success, else a negative error code encoded
184  *   in the return pointer.
185  */
186 static struct dentry *
187 vxfs_lookup(struct inode *dip, struct dentry *dp, unsigned int flags)
188 {
189         struct inode            *ip = NULL;
190         ino_t                   ino;
191                          
192         if (dp->d_name.len > VXFS_NAMELEN)
193                 return ERR_PTR(-ENAMETOOLONG);
194                                  
195         ino = vxfs_inode_by_name(dip, dp);
196         if (ino)
197                 ip = vxfs_iget(dip->i_sb, ino);
198         return d_splice_alias(ip, dp);
199 }
200 
201 /**
202  * vxfs_readdir - read a directory
203  * @fp:         the directory to read
204  * @retp:       return buffer
205  * @filler:     filldir callback
206  *
207  * Description:
208  *   vxfs_readdir fills @retp with directory entries from @fp
209  *   using the VFS supplied callback @filler.
210  *
211  * Returns:
212  *   Zero.
213  */
214 static int
215 vxfs_readdir(struct file *fp, struct dir_context *ctx)
216 {
217         struct inode            *ip = file_inode(fp);
218         struct super_block      *sbp = ip->i_sb;
219         u_long                  bsize = sbp->s_blocksize;
220         loff_t                  pos, limit;
221         struct vxfs_sb_info     *sbi = VXFS_SBI(sbp);
222 
223         if (ctx->pos == 0) {
224                 if (!dir_emit_dot(fp, ctx))
225                         goto out;
226                 ctx->pos++;
227         }
228         if (ctx->pos == 1) {
229                 if (!dir_emit(ctx, "..", 2, VXFS_INO(ip)->vii_dotdot, DT_DIR))
230                         goto out;
231                 ctx->pos++;
232         }
233 
234         limit = VXFS_DIRROUND(ip->i_size);
235         if (ctx->pos > limit)
236                 goto out;
237 
238         pos = ctx->pos & ~3L;
239 
240         while (pos < limit) {
241                 struct page *pp;
242                 char *kaddr;
243                 int pg_ofs = pos & ~PAGE_MASK;
244                 int rc = 0;
245 
246                 pp = vxfs_get_page(ip->i_mapping, pos >> PAGE_SHIFT);
247                 if (IS_ERR(pp))
248                         return -ENOMEM;
249 
250                 kaddr = (char *)page_address(pp);
251 
252                 while (pg_ofs < PAGE_SIZE && pos < limit) {
253                         struct vxfs_direct *de;
254 
255                         if ((pos & (bsize - 1)) < 4) {
256                                 struct vxfs_dirblk *dbp =
257                                         (struct vxfs_dirblk *)
258                                          (kaddr + (pos & ~PAGE_MASK));
259                                 int overhead = VXFS_DIRBLKOV(sbi, dbp);
260 
261                                 pos += overhead;
262                                 pg_ofs += overhead;
263                         }
264                         de = (struct vxfs_direct *)(kaddr + pg_ofs);
265 
266                         if (!de->d_reclen) {
267                                 pos += bsize - 1;
268                                 pos &= ~(bsize - 1);
269                                 break;
270                         }
271 
272                         pg_ofs += fs16_to_cpu(sbi, de->d_reclen);
273                         pos += fs16_to_cpu(sbi, de->d_reclen);
274                         if (!de->d_ino)
275                                 continue;
276 
277                         rc = dir_emit(ctx, de->d_name,
278                                         fs16_to_cpu(sbi, de->d_namelen),
279                                         fs32_to_cpu(sbi, de->d_ino),
280                                         DT_UNKNOWN);
281                         if (!rc) {
282                                 /* the dir entry was not read, fix pos. */
283                                 pos -= fs16_to_cpu(sbi, de->d_reclen);
284                                 break;
285                         }
286                 }
287                 vxfs_put_page(pp);
288                 if (!rc)
289                         break;
290         }
291 
292         ctx->pos = pos | 2;
293 
294 out:
295         return 0;
296 }
297 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp