Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * NILFS directory entry operations
0004  *
0005  * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
0006  *
0007  * Modified for NILFS by Amagai Yoshiji.
0008  */
0009 /*
0010  *  linux/fs/ext2/dir.c
0011  *
0012  * Copyright (C) 1992, 1993, 1994, 1995
0013  * Remy Card (card@masi.ibp.fr)
0014  * Laboratoire MASI - Institut Blaise Pascal
0015  * Universite Pierre et Marie Curie (Paris VI)
0016  *
0017  *  from
0018  *
0019  *  linux/fs/minix/dir.c
0020  *
0021  *  Copyright (C) 1991, 1992  Linus Torvalds
0022  *
0023  *  ext2 directory handling functions
0024  *
0025  *  Big-endian to little-endian byte-swapping/bitmaps by
0026  *        David S. Miller (davem@caip.rutgers.edu), 1995
0027  *
0028  * All code that works with directory layout had been switched to pagecache
0029  * and moved here. AV
0030  */
0031 
0032 #include <linux/pagemap.h>
0033 #include "nilfs.h"
0034 #include "page.h"
0035 
0036 static inline unsigned int nilfs_rec_len_from_disk(__le16 dlen)
0037 {
0038     unsigned int len = le16_to_cpu(dlen);
0039 
0040 #if (PAGE_SIZE >= 65536)
0041     if (len == NILFS_MAX_REC_LEN)
0042         return 1 << 16;
0043 #endif
0044     return len;
0045 }
0046 
0047 static inline __le16 nilfs_rec_len_to_disk(unsigned int len)
0048 {
0049 #if (PAGE_SIZE >= 65536)
0050     if (len == (1 << 16))
0051         return cpu_to_le16(NILFS_MAX_REC_LEN);
0052 
0053     BUG_ON(len > (1 << 16));
0054 #endif
0055     return cpu_to_le16(len);
0056 }
0057 
0058 /*
0059  * nilfs uses block-sized chunks. Arguably, sector-sized ones would be
0060  * more robust, but we have what we have
0061  */
0062 static inline unsigned int nilfs_chunk_size(struct inode *inode)
0063 {
0064     return inode->i_sb->s_blocksize;
0065 }
0066 
0067 static inline void nilfs_put_page(struct page *page)
0068 {
0069     kunmap(page);
0070     put_page(page);
0071 }
0072 
0073 /*
0074  * Return the offset into page `page_nr' of the last valid
0075  * byte in that page, plus one.
0076  */
0077 static unsigned int nilfs_last_byte(struct inode *inode, unsigned long page_nr)
0078 {
0079     unsigned int last_byte = inode->i_size;
0080 
0081     last_byte -= page_nr << PAGE_SHIFT;
0082     if (last_byte > PAGE_SIZE)
0083         last_byte = PAGE_SIZE;
0084     return last_byte;
0085 }
0086 
0087 static int nilfs_prepare_chunk(struct page *page, unsigned int from,
0088                    unsigned int to)
0089 {
0090     loff_t pos = page_offset(page) + from;
0091 
0092     return __block_write_begin(page, pos, to - from, nilfs_get_block);
0093 }
0094 
0095 static void nilfs_commit_chunk(struct page *page,
0096                    struct address_space *mapping,
0097                    unsigned int from, unsigned int to)
0098 {
0099     struct inode *dir = mapping->host;
0100     loff_t pos = page_offset(page) + from;
0101     unsigned int len = to - from;
0102     unsigned int nr_dirty, copied;
0103     int err;
0104 
0105     nr_dirty = nilfs_page_count_clean_buffers(page, from, to);
0106     copied = block_write_end(NULL, mapping, pos, len, len, page, NULL);
0107     if (pos + copied > dir->i_size)
0108         i_size_write(dir, pos + copied);
0109     if (IS_DIRSYNC(dir))
0110         nilfs_set_transaction_flag(NILFS_TI_SYNC);
0111     err = nilfs_set_file_dirty(dir, nr_dirty);
0112     WARN_ON(err); /* do not happen */
0113     unlock_page(page);
0114 }
0115 
0116 static bool nilfs_check_page(struct page *page)
0117 {
0118     struct inode *dir = page->mapping->host;
0119     struct super_block *sb = dir->i_sb;
0120     unsigned int chunk_size = nilfs_chunk_size(dir);
0121     char *kaddr = page_address(page);
0122     unsigned int offs, rec_len;
0123     unsigned int limit = PAGE_SIZE;
0124     struct nilfs_dir_entry *p;
0125     char *error;
0126 
0127     if ((dir->i_size >> PAGE_SHIFT) == page->index) {
0128         limit = dir->i_size & ~PAGE_MASK;
0129         if (limit & (chunk_size - 1))
0130             goto Ebadsize;
0131         if (!limit)
0132             goto out;
0133     }
0134     for (offs = 0; offs <= limit - NILFS_DIR_REC_LEN(1); offs += rec_len) {
0135         p = (struct nilfs_dir_entry *)(kaddr + offs);
0136         rec_len = nilfs_rec_len_from_disk(p->rec_len);
0137 
0138         if (rec_len < NILFS_DIR_REC_LEN(1))
0139             goto Eshort;
0140         if (rec_len & 3)
0141             goto Ealign;
0142         if (rec_len < NILFS_DIR_REC_LEN(p->name_len))
0143             goto Enamelen;
0144         if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1))
0145             goto Espan;
0146     }
0147     if (offs != limit)
0148         goto Eend;
0149 out:
0150     SetPageChecked(page);
0151     return true;
0152 
0153     /* Too bad, we had an error */
0154 
0155 Ebadsize:
0156     nilfs_error(sb,
0157             "size of directory #%lu is not a multiple of chunk size",
0158             dir->i_ino);
0159     goto fail;
0160 Eshort:
0161     error = "rec_len is smaller than minimal";
0162     goto bad_entry;
0163 Ealign:
0164     error = "unaligned directory entry";
0165     goto bad_entry;
0166 Enamelen:
0167     error = "rec_len is too small for name_len";
0168     goto bad_entry;
0169 Espan:
0170     error = "directory entry across blocks";
0171 bad_entry:
0172     nilfs_error(sb,
0173             "bad entry in directory #%lu: %s - offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
0174             dir->i_ino, error, (page->index << PAGE_SHIFT) + offs,
0175             (unsigned long)le64_to_cpu(p->inode),
0176             rec_len, p->name_len);
0177     goto fail;
0178 Eend:
0179     p = (struct nilfs_dir_entry *)(kaddr + offs);
0180     nilfs_error(sb,
0181             "entry in directory #%lu spans the page boundary offset=%lu, inode=%lu",
0182             dir->i_ino, (page->index << PAGE_SHIFT) + offs,
0183             (unsigned long)le64_to_cpu(p->inode));
0184 fail:
0185     SetPageError(page);
0186     return false;
0187 }
0188 
0189 static struct page *nilfs_get_page(struct inode *dir, unsigned long n)
0190 {
0191     struct address_space *mapping = dir->i_mapping;
0192     struct page *page = read_mapping_page(mapping, n, NULL);
0193 
0194     if (!IS_ERR(page)) {
0195         kmap(page);
0196         if (unlikely(!PageChecked(page))) {
0197             if (!nilfs_check_page(page))
0198                 goto fail;
0199         }
0200     }
0201     return page;
0202 
0203 fail:
0204     nilfs_put_page(page);
0205     return ERR_PTR(-EIO);
0206 }
0207 
0208 /*
0209  * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure.
0210  *
0211  * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller.
0212  */
0213 static int
0214 nilfs_match(int len, const unsigned char *name, struct nilfs_dir_entry *de)
0215 {
0216     if (len != de->name_len)
0217         return 0;
0218     if (!de->inode)
0219         return 0;
0220     return !memcmp(name, de->name, len);
0221 }
0222 
0223 /*
0224  * p is at least 6 bytes before the end of page
0225  */
0226 static struct nilfs_dir_entry *nilfs_next_entry(struct nilfs_dir_entry *p)
0227 {
0228     return (struct nilfs_dir_entry *)((char *)p +
0229                       nilfs_rec_len_from_disk(p->rec_len));
0230 }
0231 
0232 static unsigned char
0233 nilfs_filetype_table[NILFS_FT_MAX] = {
0234     [NILFS_FT_UNKNOWN]  = DT_UNKNOWN,
0235     [NILFS_FT_REG_FILE] = DT_REG,
0236     [NILFS_FT_DIR]      = DT_DIR,
0237     [NILFS_FT_CHRDEV]   = DT_CHR,
0238     [NILFS_FT_BLKDEV]   = DT_BLK,
0239     [NILFS_FT_FIFO]     = DT_FIFO,
0240     [NILFS_FT_SOCK]     = DT_SOCK,
0241     [NILFS_FT_SYMLINK]  = DT_LNK,
0242 };
0243 
0244 #define S_SHIFT 12
0245 static unsigned char
0246 nilfs_type_by_mode[S_IFMT >> S_SHIFT] = {
0247     [S_IFREG >> S_SHIFT]    = NILFS_FT_REG_FILE,
0248     [S_IFDIR >> S_SHIFT]    = NILFS_FT_DIR,
0249     [S_IFCHR >> S_SHIFT]    = NILFS_FT_CHRDEV,
0250     [S_IFBLK >> S_SHIFT]    = NILFS_FT_BLKDEV,
0251     [S_IFIFO >> S_SHIFT]    = NILFS_FT_FIFO,
0252     [S_IFSOCK >> S_SHIFT]   = NILFS_FT_SOCK,
0253     [S_IFLNK >> S_SHIFT]    = NILFS_FT_SYMLINK,
0254 };
0255 
0256 static void nilfs_set_de_type(struct nilfs_dir_entry *de, struct inode *inode)
0257 {
0258     umode_t mode = inode->i_mode;
0259 
0260     de->file_type = nilfs_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
0261 }
0262 
0263 static int nilfs_readdir(struct file *file, struct dir_context *ctx)
0264 {
0265     loff_t pos = ctx->pos;
0266     struct inode *inode = file_inode(file);
0267     struct super_block *sb = inode->i_sb;
0268     unsigned int offset = pos & ~PAGE_MASK;
0269     unsigned long n = pos >> PAGE_SHIFT;
0270     unsigned long npages = dir_pages(inode);
0271 
0272     if (pos > inode->i_size - NILFS_DIR_REC_LEN(1))
0273         return 0;
0274 
0275     for ( ; n < npages; n++, offset = 0) {
0276         char *kaddr, *limit;
0277         struct nilfs_dir_entry *de;
0278         struct page *page = nilfs_get_page(inode, n);
0279 
0280         if (IS_ERR(page)) {
0281             nilfs_error(sb, "bad page in #%lu", inode->i_ino);
0282             ctx->pos += PAGE_SIZE - offset;
0283             return -EIO;
0284         }
0285         kaddr = page_address(page);
0286         de = (struct nilfs_dir_entry *)(kaddr + offset);
0287         limit = kaddr + nilfs_last_byte(inode, n) -
0288             NILFS_DIR_REC_LEN(1);
0289         for ( ; (char *)de <= limit; de = nilfs_next_entry(de)) {
0290             if (de->rec_len == 0) {
0291                 nilfs_error(sb, "zero-length directory entry");
0292                 nilfs_put_page(page);
0293                 return -EIO;
0294             }
0295             if (de->inode) {
0296                 unsigned char t;
0297 
0298                 if (de->file_type < NILFS_FT_MAX)
0299                     t = nilfs_filetype_table[de->file_type];
0300                 else
0301                     t = DT_UNKNOWN;
0302 
0303                 if (!dir_emit(ctx, de->name, de->name_len,
0304                         le64_to_cpu(de->inode), t)) {
0305                     nilfs_put_page(page);
0306                     return 0;
0307                 }
0308             }
0309             ctx->pos += nilfs_rec_len_from_disk(de->rec_len);
0310         }
0311         nilfs_put_page(page);
0312     }
0313     return 0;
0314 }
0315 
0316 /*
0317  *  nilfs_find_entry()
0318  *
0319  * finds an entry in the specified directory with the wanted name. It
0320  * returns the page in which the entry was found, and the entry itself
0321  * (as a parameter - res_dir). Page is returned mapped and unlocked.
0322  * Entry is guaranteed to be valid.
0323  */
0324 struct nilfs_dir_entry *
0325 nilfs_find_entry(struct inode *dir, const struct qstr *qstr,
0326          struct page **res_page)
0327 {
0328     const unsigned char *name = qstr->name;
0329     int namelen = qstr->len;
0330     unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
0331     unsigned long start, n;
0332     unsigned long npages = dir_pages(dir);
0333     struct page *page = NULL;
0334     struct nilfs_inode_info *ei = NILFS_I(dir);
0335     struct nilfs_dir_entry *de;
0336 
0337     if (npages == 0)
0338         goto out;
0339 
0340     /* OFFSET_CACHE */
0341     *res_page = NULL;
0342 
0343     start = ei->i_dir_start_lookup;
0344     if (start >= npages)
0345         start = 0;
0346     n = start;
0347     do {
0348         char *kaddr;
0349 
0350         page = nilfs_get_page(dir, n);
0351         if (!IS_ERR(page)) {
0352             kaddr = page_address(page);
0353             de = (struct nilfs_dir_entry *)kaddr;
0354             kaddr += nilfs_last_byte(dir, n) - reclen;
0355             while ((char *) de <= kaddr) {
0356                 if (de->rec_len == 0) {
0357                     nilfs_error(dir->i_sb,
0358                         "zero-length directory entry");
0359                     nilfs_put_page(page);
0360                     goto out;
0361                 }
0362                 if (nilfs_match(namelen, name, de))
0363                     goto found;
0364                 de = nilfs_next_entry(de);
0365             }
0366             nilfs_put_page(page);
0367         }
0368         if (++n >= npages)
0369             n = 0;
0370         /* next page is past the blocks we've got */
0371         if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) {
0372             nilfs_error(dir->i_sb,
0373                    "dir %lu size %lld exceeds block count %llu",
0374                    dir->i_ino, dir->i_size,
0375                    (unsigned long long)dir->i_blocks);
0376             goto out;
0377         }
0378     } while (n != start);
0379 out:
0380     return NULL;
0381 
0382 found:
0383     *res_page = page;
0384     ei->i_dir_start_lookup = n;
0385     return de;
0386 }
0387 
0388 struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct page **p)
0389 {
0390     struct page *page = nilfs_get_page(dir, 0);
0391     struct nilfs_dir_entry *de = NULL;
0392 
0393     if (!IS_ERR(page)) {
0394         de = nilfs_next_entry(
0395             (struct nilfs_dir_entry *)page_address(page));
0396         *p = page;
0397     }
0398     return de;
0399 }
0400 
0401 ino_t nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr)
0402 {
0403     ino_t res = 0;
0404     struct nilfs_dir_entry *de;
0405     struct page *page;
0406 
0407     de = nilfs_find_entry(dir, qstr, &page);
0408     if (de) {
0409         res = le64_to_cpu(de->inode);
0410         kunmap(page);
0411         put_page(page);
0412     }
0413     return res;
0414 }
0415 
0416 /* Releases the page */
0417 void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
0418             struct page *page, struct inode *inode)
0419 {
0420     unsigned int from = (char *)de - (char *)page_address(page);
0421     unsigned int to = from + nilfs_rec_len_from_disk(de->rec_len);
0422     struct address_space *mapping = page->mapping;
0423     int err;
0424 
0425     lock_page(page);
0426     err = nilfs_prepare_chunk(page, from, to);
0427     BUG_ON(err);
0428     de->inode = cpu_to_le64(inode->i_ino);
0429     nilfs_set_de_type(de, inode);
0430     nilfs_commit_chunk(page, mapping, from, to);
0431     nilfs_put_page(page);
0432     dir->i_mtime = dir->i_ctime = current_time(dir);
0433 }
0434 
0435 /*
0436  *  Parent is locked.
0437  */
0438 int nilfs_add_link(struct dentry *dentry, struct inode *inode)
0439 {
0440     struct inode *dir = d_inode(dentry->d_parent);
0441     const unsigned char *name = dentry->d_name.name;
0442     int namelen = dentry->d_name.len;
0443     unsigned int chunk_size = nilfs_chunk_size(dir);
0444     unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
0445     unsigned short rec_len, name_len;
0446     struct page *page = NULL;
0447     struct nilfs_dir_entry *de;
0448     unsigned long npages = dir_pages(dir);
0449     unsigned long n;
0450     char *kaddr;
0451     unsigned int from, to;
0452     int err;
0453 
0454     /*
0455      * We take care of directory expansion in the same loop.
0456      * This code plays outside i_size, so it locks the page
0457      * to protect that region.
0458      */
0459     for (n = 0; n <= npages; n++) {
0460         char *dir_end;
0461 
0462         page = nilfs_get_page(dir, n);
0463         err = PTR_ERR(page);
0464         if (IS_ERR(page))
0465             goto out;
0466         lock_page(page);
0467         kaddr = page_address(page);
0468         dir_end = kaddr + nilfs_last_byte(dir, n);
0469         de = (struct nilfs_dir_entry *)kaddr;
0470         kaddr += PAGE_SIZE - reclen;
0471         while ((char *)de <= kaddr) {
0472             if ((char *)de == dir_end) {
0473                 /* We hit i_size */
0474                 name_len = 0;
0475                 rec_len = chunk_size;
0476                 de->rec_len = nilfs_rec_len_to_disk(chunk_size);
0477                 de->inode = 0;
0478                 goto got_it;
0479             }
0480             if (de->rec_len == 0) {
0481                 nilfs_error(dir->i_sb,
0482                         "zero-length directory entry");
0483                 err = -EIO;
0484                 goto out_unlock;
0485             }
0486             err = -EEXIST;
0487             if (nilfs_match(namelen, name, de))
0488                 goto out_unlock;
0489             name_len = NILFS_DIR_REC_LEN(de->name_len);
0490             rec_len = nilfs_rec_len_from_disk(de->rec_len);
0491             if (!de->inode && rec_len >= reclen)
0492                 goto got_it;
0493             if (rec_len >= name_len + reclen)
0494                 goto got_it;
0495             de = (struct nilfs_dir_entry *)((char *)de + rec_len);
0496         }
0497         unlock_page(page);
0498         nilfs_put_page(page);
0499     }
0500     BUG();
0501     return -EINVAL;
0502 
0503 got_it:
0504     from = (char *)de - (char *)page_address(page);
0505     to = from + rec_len;
0506     err = nilfs_prepare_chunk(page, from, to);
0507     if (err)
0508         goto out_unlock;
0509     if (de->inode) {
0510         struct nilfs_dir_entry *de1;
0511 
0512         de1 = (struct nilfs_dir_entry *)((char *)de + name_len);
0513         de1->rec_len = nilfs_rec_len_to_disk(rec_len - name_len);
0514         de->rec_len = nilfs_rec_len_to_disk(name_len);
0515         de = de1;
0516     }
0517     de->name_len = namelen;
0518     memcpy(de->name, name, namelen);
0519     de->inode = cpu_to_le64(inode->i_ino);
0520     nilfs_set_de_type(de, inode);
0521     nilfs_commit_chunk(page, page->mapping, from, to);
0522     dir->i_mtime = dir->i_ctime = current_time(dir);
0523     nilfs_mark_inode_dirty(dir);
0524     /* OFFSET_CACHE */
0525 out_put:
0526     nilfs_put_page(page);
0527 out:
0528     return err;
0529 out_unlock:
0530     unlock_page(page);
0531     goto out_put;
0532 }
0533 
0534 /*
0535  * nilfs_delete_entry deletes a directory entry by merging it with the
0536  * previous entry. Page is up-to-date. Releases the page.
0537  */
0538 int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)
0539 {
0540     struct address_space *mapping = page->mapping;
0541     struct inode *inode = mapping->host;
0542     char *kaddr = page_address(page);
0543     unsigned int from, to;
0544     struct nilfs_dir_entry *de, *pde = NULL;
0545     int err;
0546 
0547     from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1);
0548     to = ((char *)dir - kaddr) + nilfs_rec_len_from_disk(dir->rec_len);
0549     de = (struct nilfs_dir_entry *)(kaddr + from);
0550 
0551     while ((char *)de < (char *)dir) {
0552         if (de->rec_len == 0) {
0553             nilfs_error(inode->i_sb,
0554                     "zero-length directory entry");
0555             err = -EIO;
0556             goto out;
0557         }
0558         pde = de;
0559         de = nilfs_next_entry(de);
0560     }
0561     if (pde)
0562         from = (char *)pde - (char *)page_address(page);
0563     lock_page(page);
0564     err = nilfs_prepare_chunk(page, from, to);
0565     BUG_ON(err);
0566     if (pde)
0567         pde->rec_len = nilfs_rec_len_to_disk(to - from);
0568     dir->inode = 0;
0569     nilfs_commit_chunk(page, mapping, from, to);
0570     inode->i_ctime = inode->i_mtime = current_time(inode);
0571 out:
0572     nilfs_put_page(page);
0573     return err;
0574 }
0575 
0576 /*
0577  * Set the first fragment of directory.
0578  */
0579 int nilfs_make_empty(struct inode *inode, struct inode *parent)
0580 {
0581     struct address_space *mapping = inode->i_mapping;
0582     struct page *page = grab_cache_page(mapping, 0);
0583     unsigned int chunk_size = nilfs_chunk_size(inode);
0584     struct nilfs_dir_entry *de;
0585     int err;
0586     void *kaddr;
0587 
0588     if (!page)
0589         return -ENOMEM;
0590 
0591     err = nilfs_prepare_chunk(page, 0, chunk_size);
0592     if (unlikely(err)) {
0593         unlock_page(page);
0594         goto fail;
0595     }
0596     kaddr = kmap_atomic(page);
0597     memset(kaddr, 0, chunk_size);
0598     de = (struct nilfs_dir_entry *)kaddr;
0599     de->name_len = 1;
0600     de->rec_len = nilfs_rec_len_to_disk(NILFS_DIR_REC_LEN(1));
0601     memcpy(de->name, ".\0\0", 4);
0602     de->inode = cpu_to_le64(inode->i_ino);
0603     nilfs_set_de_type(de, inode);
0604 
0605     de = (struct nilfs_dir_entry *)(kaddr + NILFS_DIR_REC_LEN(1));
0606     de->name_len = 2;
0607     de->rec_len = nilfs_rec_len_to_disk(chunk_size - NILFS_DIR_REC_LEN(1));
0608     de->inode = cpu_to_le64(parent->i_ino);
0609     memcpy(de->name, "..\0", 4);
0610     nilfs_set_de_type(de, inode);
0611     kunmap_atomic(kaddr);
0612     nilfs_commit_chunk(page, mapping, 0, chunk_size);
0613 fail:
0614     put_page(page);
0615     return err;
0616 }
0617 
0618 /*
0619  * routine to check that the specified directory is empty (for rmdir)
0620  */
0621 int nilfs_empty_dir(struct inode *inode)
0622 {
0623     struct page *page = NULL;
0624     unsigned long i, npages = dir_pages(inode);
0625 
0626     for (i = 0; i < npages; i++) {
0627         char *kaddr;
0628         struct nilfs_dir_entry *de;
0629 
0630         page = nilfs_get_page(inode, i);
0631         if (IS_ERR(page))
0632             continue;
0633 
0634         kaddr = page_address(page);
0635         de = (struct nilfs_dir_entry *)kaddr;
0636         kaddr += nilfs_last_byte(inode, i) - NILFS_DIR_REC_LEN(1);
0637 
0638         while ((char *)de <= kaddr) {
0639             if (de->rec_len == 0) {
0640                 nilfs_error(inode->i_sb,
0641                         "zero-length directory entry (kaddr=%p, de=%p)",
0642                         kaddr, de);
0643                 goto not_empty;
0644             }
0645             if (de->inode != 0) {
0646                 /* check for . and .. */
0647                 if (de->name[0] != '.')
0648                     goto not_empty;
0649                 if (de->name_len > 2)
0650                     goto not_empty;
0651                 if (de->name_len < 2) {
0652                     if (de->inode !=
0653                         cpu_to_le64(inode->i_ino))
0654                         goto not_empty;
0655                 } else if (de->name[1] != '.')
0656                     goto not_empty;
0657             }
0658             de = nilfs_next_entry(de);
0659         }
0660         nilfs_put_page(page);
0661     }
0662     return 1;
0663 
0664 not_empty:
0665     nilfs_put_page(page);
0666     return 0;
0667 }
0668 
0669 const struct file_operations nilfs_dir_operations = {
0670     .llseek     = generic_file_llseek,
0671     .read       = generic_read_dir,
0672     .iterate_shared = nilfs_readdir,
0673     .unlocked_ioctl = nilfs_ioctl,
0674 #ifdef CONFIG_COMPAT
0675     .compat_ioctl   = nilfs_compat_ioctl,
0676 #endif  /* CONFIG_COMPAT */
0677     .fsync      = nilfs_sync_file,
0678 
0679 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!