fs/sysv/dir.c

   1 /*
   2  *  linux/fs/sysv/dir.c
   3  *
   4  *  minix/dir.c
   5  *  Copyright (C) 1991, 1992  Linus Torvalds
   6  *
   7  *  coh/dir.c
   8  *  Copyright (C) 1993  Pascal Haible, Bruno Haible
   9  *
  10  *  sysv/dir.c
  11  *  Copyright (C) 1993  Bruno Haible
  12  *
  13  *  SystemV/Coherent directory handling functions
  14  */
  15
  16 #include <linux/pagemap.h>
  17 #include <linux/highmem.h>
  18 #include <linux/swap.h>
  19 #include "sysv.h"
  20
  21 static int sysv_readdir(struct file *, void *, filldir_t);
  22
  23 const struct file_operations sysv_dir_operations = {
  24         .llseek         = generic_file_llseek,
  25         .read           = generic_read_dir,
  26         .readdir        = sysv_readdir,
  27         .fsync          = generic_file_fsync,
  28 };
  29
  30 static inline void dir_put_page(struct page *page)
  31 {
  32         kunmap(page);
  33         page_cache_release(page);
  34 }
  35
  36 static inline unsigned long dir_pages(struct inode *inode)
  37 {
  38         return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
  39 }
  40
  41 static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len)
  42 {
  43         struct address_space *mapping = page->mapping;
  44         struct inode *dir = mapping->host;
  45         int err = 0;
  46
  47         block_write_end(NULL, mapping, pos, len, len, page, NULL);
  48         if (pos+len > dir->i_size) {
  49                 i_size_write(dir, pos+len);
  50                 mark_inode_dirty(dir);
  51         }
  52         if (IS_DIRSYNC(dir))
  53                 err = write_one_page(page, 1);
  54         else
  55                 unlock_page(page);
  56         return err;
  57 }
  58
  59 static struct page * dir_get_page(struct inode *dir, unsigned long n)
  60 {
  61         struct address_space *mapping = dir->i_mapping;
  62         struct page *page = read_mapping_page(mapping, n, NULL);
  63         if (!IS_ERR(page))
  64                 kmap(page);
  65         return page;
  66 }
  67
  68 static int sysv_readdir(struct file * filp, void * dirent, filldir_t filldir)
  69 {
  70         unsigned long pos = filp->f_pos;
  71         struct inode *inode = filp->f_path.dentry->d_inode;
  72         struct super_block *sb = inode->i_sb;
  73         unsigned offset = pos & ~PAGE_CACHE_MASK;
  74         unsigned long n = pos >> PAGE_CACHE_SHIFT;
  75         unsigned long npages = dir_pages(inode);
  76
  77         pos = (pos + SYSV_DIRSIZE-1) & ~(SYSV_DIRSIZE-1);
  78         if (pos >= inode->i_size)
  79                 goto done;
  80
  81         for ( ; n < npages; n++, offset = 0) {
  82                 char *kaddr, *limit;
  83                 struct sysv_dir_entry *de;
  84                 struct page *page = dir_get_page(inode, n);
  85
  86                 if (IS_ERR(page))
  87                         continue;
  88                 kaddr = (char *)page_address(page);
  89                 de = (struct sysv_dir_entry *)(kaddr+offset);
  90                 limit = kaddr + PAGE_CACHE_SIZE - SYSV_DIRSIZE;
  91                 for ( ;(char*)de <= limit; de++) {
  92                         char *name = de->name;
  93                         int over;
  94
  95                         if (!de->inode)
  96                                 continue;
  97
  98                         offset = (char *)de - kaddr;
  99
 100                         over = filldir(dirent, name, strnlen(name,SYSV_NAMELEN),
 101                                         ((loff_t)n<<PAGE_CACHE_SHIFT) | offset,
 102                                         fs16_to_cpu(SYSV_SB(sb), de->inode),
 103                                         DT_UNKNOWN);
 104                         if (over) {
 105                                 dir_put_page(page);
 106                                 goto done;
 107                         }
 108                 }
 109                 dir_put_page(page);
 110         }
 111
 112 done:
 113         filp->f_pos = ((loff_t)n << PAGE_CACHE_SHIFT) | offset;
 114         return 0;
 115 }
 116
 117 /* compare strings: name[0..len-1] (not zero-terminated) and
 118  * buffer[0..] (filled with zeroes up to buffer[0..maxlen-1])
 119  */
 120 static inline int namecompare(int len, int maxlen,
 121         const char * name, const char * buffer)
 122 {
 123         if (len < maxlen && buffer[len])
 124                 return 0;
 125         return !memcmp(name, buffer, len);
 126 }
 127
 128 /*
 129  *      sysv_find_entry()
 130  *
 131  * finds an entry in the specified directory with the wanted name. It
 132  * returns the cache buffer in which the entry was found, and the entry
 133  * itself (as a parameter - res_dir). It does NOT read the inode of the
 134  * entry - you'll have to do that yourself if you want to.
 135  */
 136 struct sysv_dir_entry *sysv_find_entry(struct dentry *dentry, struct page **res_page)
 137 {
 138         const char * name = dentry->d_name.name;
 139         int namelen = dentry->d_name.len;
 140         struct inode * dir = dentry->d_parent->d_inode;
 141         unsigned long start, n;
 142         unsigned long npages = dir_pages(dir);
 143         struct page *page = NULL;
 144         struct sysv_dir_entry *de;
 145
 146         *res_page = NULL;
 147
 148         start = SYSV_I(dir)->i_dir_start_lookup;
 149         if (start >= npages)
 150                 start = 0;
 151         n = start;
 152
 153         do {
 154                 char *kaddr;
 155                 page = dir_get_page(dir, n);
 156                 if (!IS_ERR(page)) {
 157                         kaddr = (char*)page_address(page);
 158                         de = (struct sysv_dir_entry *) kaddr;
 159                         kaddr += PAGE_CACHE_SIZE - SYSV_DIRSIZE;
 160                         for ( ; (char *) de <= kaddr ; de++) {
 161                                 if (!de->inode)
 162                                         continue;
 163                                 if (namecompare(namelen, SYSV_NAMELEN,
 164                                                         name, de->name))
 165                                         goto found;
 166                         }
 167                         dir_put_page(page);
 168                 }
 169
 170                 if (++n >= npages)
 171                         n = 0;
 172         } while (n != start);
 173
 174         return NULL;
 175
 176 found:
 177         SYSV_I(dir)->i_dir_start_lookup = n;
 178         *res_page = page;
 179         return de;
 180 }
 181
 182 int sysv_add_link(struct dentry *dentry, struct inode *inode)
 183 {
 184         struct inode *dir = dentry->d_parent->d_inode;
 185         const char * name = dentry->d_name.name;
 186         int namelen = dentry->d_name.len;
 187         struct page *page = NULL;
 188         struct sysv_dir_entry * de;
 189         unsigned long npages = dir_pages(dir);
 190         unsigned long n;
 191         char *kaddr;
 192         loff_t pos;
 193         int err;
 194
 195         /* We take care of directory expansion in the same loop */
 196         for (n = 0; n <= npages; n++) {
 197                 page = dir_get_page(dir, n);
 198                 err = PTR_ERR(page);
 199                 if (IS_ERR(page))
 200                         goto out;
 201                 kaddr = (char*)page_address(page);
 202                 de = (struct sysv_dir_entry *)kaddr;
 203                 kaddr += PAGE_CACHE_SIZE - SYSV_DIRSIZE;
 204                 while ((char *)de <= kaddr) {
 205                         if (!de->inode)
 206                                 goto got_it;
 207                         err = -EEXIST;
 208                         if (namecompare(namelen, SYSV_NAMELEN, name, de->name))
 209                                 goto out_page;
 210                         de++;
 211                 }
 212                 dir_put_page(page);
 213         }
 214         BUG();
 215         return -EINVAL;
 216
 217 got_it:
 218         pos = page_offset(page) +
 219                         (char*)de - (char*)page_address(page);
 220         lock_page(page);
 221         err = __sysv_write_begin(NULL, page->mapping, pos, SYSV_DIRSIZE,
 222                                 AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
 223         if (err)
 224                 goto out_unlock;
 225         memcpy (de->name, name, namelen);
 226         memset (de->name + namelen, 0, SYSV_DIRSIZE - namelen - 2);
 227         de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
 228         err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
 229         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
 230         mark_inode_dirty(dir);
 231 out_page:
 232         dir_put_page(page);
 233 out:
 234         return err;
 235 out_unlock:
 236         unlock_page(page);
 237         goto out_page;
 238 }
 239
 240 int sysv_delete_entry(struct sysv_dir_entry *de, struct page *page)
 241 {
 242         struct address_space *mapping = page->mapping;
 243         struct inode *inode = (struct inode*)mapping->host;
 244         char *kaddr = (char*)page_address(page);
 245         loff_t pos = page_offset(page) + (char *)de - kaddr;
 246         int err;
 247
 248         lock_page(page);
 249         err = __sysv_write_begin(NULL, mapping, pos, SYSV_DIRSIZE,
 250                                 AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
 251         BUG_ON(err);
 252         de->inode = 0;
 253         err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
 254         dir_put_page(page);
 255         inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 256         mark_inode_dirty(inode);
 257         return err;
 258 }
 259
 260 int sysv_make_empty(struct inode *inode, struct inode *dir)
 261 {
 262         struct address_space *mapping = inode->i_mapping;
 263         struct page *page = grab_cache_page(mapping, 0);
 264         struct sysv_dir_entry * de;
 265         char *base;
 266         int err;
 267
 268         if (!page)
 269                 return -ENOMEM;
 270         err = __sysv_write_begin(NULL, mapping, 0, 2 * SYSV_DIRSIZE,
 271                                 AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
 272         if (err) {
 273                 unlock_page(page);
 274                 goto fail;
 275         }
 276         kmap(page);
 277
 278         base = (char*)page_address(page);
 279         memset(base, 0, PAGE_CACHE_SIZE);
 280
 281         de = (struct sysv_dir_entry *) base;
 282         de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
 283         strcpy(de->name,".");
 284         de++;
 285         de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), dir->i_ino);
 286         strcpy(de->name,"..");
 287
 288         kunmap(page);
 289         err = dir_commit_chunk(page, 0, 2 * SYSV_DIRSIZE);
 290 fail:
 291         page_cache_release(page);
 292         return err;
 293 }
 294
 295 /*
 296  * routine to check that the specified directory is empty (for rmdir)
 297  */
 298 int sysv_empty_dir(struct inode * inode)
 299 {
 300         struct super_block *sb = inode->i_sb;
 301         struct page *page = NULL;
 302         unsigned long i, npages = dir_pages(inode);
 303
 304         for (i = 0; i < npages; i++) {
 305                 char *kaddr;
 306                 struct sysv_dir_entry * de;
 307                 page = dir_get_page(inode, i);
 308
 309                 if (IS_ERR(page))
 310                         continue;
 311
 312                 kaddr = (char *)page_address(page);
 313                 de = (struct sysv_dir_entry *)kaddr;
 314                 kaddr += PAGE_CACHE_SIZE-SYSV_DIRSIZE;
 315
 316                 for ( ;(char *)de <= kaddr; de++) {
 317                         if (!de->inode)
 318                                 continue;
 319                         /* check for . and .. */
 320                         if (de->name[0] != '.')
 321                                 goto not_empty;
 322                         if (!de->name[1]) {
 323                                 if (de->inode == cpu_to_fs16(SYSV_SB(sb),
 324                                                         inode->i_ino))
 325                                         continue;
 326                                 goto not_empty;
 327                         }
 328                         if (de->name[1] != '.' || de->name[2])
 329                                 goto not_empty;
 330                 }
 331                 dir_put_page(page);
 332         }
 333         return 1;
 334
 335 not_empty:
 336         dir_put_page(page);
 337         return 0;
 338 }
 339
 340 /* Releases the page */
 341 void sysv_set_link(struct sysv_dir_entry *de, struct page *page,
 342         struct inode *inode)
 343 {
 344         struct address_space *mapping = page->mapping;
 345         struct inode *dir = mapping->host;
 346         loff_t pos = page_offset(page) +
 347                         (char *)de-(char*)page_address(page);
 348         int err;
 349
 350         lock_page(page);
 351         err = __sysv_write_begin(NULL, mapping, pos, SYSV_DIRSIZE,
 352                                 AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
 353         BUG_ON(err);
 354         de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
 355         err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
 356         dir_put_page(page);
 357         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
 358         mark_inode_dirty(dir);
 359 }
 360
 361 struct sysv_dir_entry * sysv_dotdot (struct inode *dir, struct page **p)
 362 {
 363         struct page *page = dir_get_page(dir, 0);
 364         struct sysv_dir_entry *de = NULL;
 365
 366         if (!IS_ERR(page)) {
 367                 de = (struct sysv_dir_entry*) page_address(page) + 1;
 368                 *p = page;
 369         }
 370         return de;
 371 }
 372
 373 ino_t sysv_inode_by_name(struct dentry *dentry)
 374 {
 375         struct page *page;
 376         struct sysv_dir_entry *de = sysv_find_entry (dentry, &page);
 377         ino_t res = 0;
 378
 379         if (de) {
 380                 res = fs16_to_cpu(SYSV_SB(dentry->d_sb), de->inode);
 381                 dir_put_page(page);
 382         }
 383         return res;
 384 }