fs/minix/dir.c

   1 /*
   2  *  linux/fs/minix/dir.c
   3  *
   4  *  Copyright (C) 1991, 1992 Linus Torvalds
   5  *
   6  *  minix directory handling functions
   7  *
   8  *  Updated to filesystem version 3 by Daniel Aragones
   9  */
  10
  11 #include "minix.h"
  12 #include <linux/buffer_head.h>
  13 #include <linux/highmem.h>
  14 #include <linux/swap.h>
  15
  16 typedef struct minix_dir_entry minix_dirent;
  17 typedef struct minix3_dir_entry minix3_dirent;
  18
  19 static int minix_readdir(struct file *, void *, filldir_t);
  20
  21 const struct file_operations minix_dir_operations = {
  22         .llseek         = generic_file_llseek,
  23         .read           = generic_read_dir,
  24         .readdir        = minix_readdir,
  25         .fsync          = generic_file_fsync,
  26 };
  27
  28 static inline void dir_put_page(struct page *page)
  29 {
  30         kunmap(page);
  31         page_cache_release(page);
  32 }
  33
  34 /*
  35  * Return the offset into page `page_nr' of the last valid
  36  * byte in that page, plus one.
  37  */
  38 static unsigned
  39 minix_last_byte(struct inode *inode, unsigned long page_nr)
  40 {
  41         unsigned last_byte = PAGE_CACHE_SIZE;
  42
  43         if (page_nr == (inode->i_size >> PAGE_CACHE_SHIFT))
  44                 last_byte = inode->i_size & (PAGE_CACHE_SIZE - 1);
  45         return last_byte;
  46 }
  47
  48 static inline unsigned long dir_pages(struct inode *inode)
  49 {
  50         return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
  51 }
  52
  53 static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len)
  54 {
  55         struct address_space *mapping = page->mapping;
  56         struct inode *dir = mapping->host;
  57         int err = 0;
  58         block_write_end(NULL, mapping, pos, len, len, page, NULL);
  59
  60         if (pos+len > dir->i_size) {
  61                 i_size_write(dir, pos+len);
  62                 mark_inode_dirty(dir);
  63         }
  64         if (IS_DIRSYNC(dir))
  65                 err = write_one_page(page, 1);
  66         else
  67                 unlock_page(page);
  68         return err;
  69 }
  70
  71 static struct page * dir_get_page(struct inode *dir, unsigned long n)
  72 {
  73         struct address_space *mapping = dir->i_mapping;
  74         struct page *page = read_mapping_page(mapping, n, NULL);
  75         if (!IS_ERR(page))
  76                 kmap(page);
  77         return page;
  78
  79 fail:
  80         dir_put_page(page);
  81         return ERR_PTR(-EIO);
  82 }
  83
  84 static inline void *minix_next_entry(void *de, struct minix_sb_info *sbi)
  85 {
  86         return (void*)((char*)de + sbi->s_dirsize);
  87 }
  88
  89 static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir)
  90 {
  91         unsigned long pos = filp->f_pos;
  92         struct inode *inode = filp->f_path.dentry->d_inode;
  93         struct super_block *sb = inode->i_sb;
  94         unsigned offset = pos & ~PAGE_CACHE_MASK;
  95         unsigned long n = pos >> PAGE_CACHE_SHIFT;
  96         unsigned long npages = dir_pages(inode);
  97         struct minix_sb_info *sbi = minix_sb(sb);
  98         unsigned chunk_size = sbi->s_dirsize;
  99         char *name;
 100         __u32 inumber;
 101
 102         pos = (pos + chunk_size-1) & ~(chunk_size-1);
 103         if (pos >= inode->i_size)
 104                 goto done;
 105
 106         for ( ; n < npages; n++, offset = 0) {
 107                 char *p, *kaddr, *limit;
 108                 struct page *page = dir_get_page(inode, n);
 109
 110                 if (IS_ERR(page))
 111                         continue;
 112                 kaddr = (char *)page_address(page);
 113                 p = kaddr+offset;
 114                 limit = kaddr + minix_last_byte(inode, n) - chunk_size;
 115                 for ( ; p <= limit; p = minix_next_entry(p, sbi)) {
 116                         if (sbi->s_version == MINIX_V3) {
 117                                 minix3_dirent *de3 = (minix3_dirent *)p;
 118                                 name = de3->name;
 119                                 inumber = de3->inode;
 120                         } else {
 121                                 minix_dirent *de = (minix_dirent *)p;
 122                                 name = de->name;
 123                                 inumber = de->inode;
 124                         }
 125                         if (inumber) {
 126                                 int over;
 127
 128                                 unsigned l = strnlen(name, sbi->s_namelen);
 129                                 offset = p - kaddr;
 130                                 over = filldir(dirent, name, l,
 131                                         (n << PAGE_CACHE_SHIFT) | offset,
 132                                         inumber, DT_UNKNOWN);
 133                                 if (over) {
 134                                         dir_put_page(page);
 135                                         goto done;
 136                                 }
 137                         }
 138                 }
 139                 dir_put_page(page);
 140         }
 141
 142 done:
 143         filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset;
 144         return 0;
 145 }
 146
 147 static inline int namecompare(int len, int maxlen,
 148         const char * name, const char * buffer)
 149 {
 150         if (len < maxlen && buffer[len])
 151                 return 0;
 152         return !memcmp(name, buffer, len);
 153 }
 154
 155 /*
 156  *      minix_find_entry()
 157  *
 158  * finds an entry in the specified directory with the wanted name. It
 159  * returns the cache buffer in which the entry was found, and the entry
 160  * itself (as a parameter - res_dir). It does NOT read the inode of the
 161  * entry - you'll have to do that yourself if you want to.
 162  */
 163 minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page)
 164 {
 165         const char * name = dentry->d_name.name;
 166         int namelen = dentry->d_name.len;
 167         struct inode * dir = dentry->d_parent->d_inode;
 168         struct super_block * sb = dir->i_sb;
 169         struct minix_sb_info * sbi = minix_sb(sb);
 170         unsigned long n;
 171         unsigned long npages = dir_pages(dir);
 172         struct page *page = NULL;
 173         char *p;
 174
 175         char *namx;
 176         __u32 inumber;
 177         *res_page = NULL;
 178
 179         for (n = 0; n < npages; n++) {
 180                 char *kaddr, *limit;
 181
 182                 page = dir_get_page(dir, n);
 183                 if (IS_ERR(page))
 184                         continue;
 185
 186                 kaddr = (char*)page_address(page);
 187                 limit = kaddr + minix_last_byte(dir, n) - sbi->s_dirsize;
 188                 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
 189                         if (sbi->s_version == MINIX_V3) {
 190                                 minix3_dirent *de3 = (minix3_dirent *)p;
 191                                 namx = de3->name;
 192                                 inumber = de3->inode;
 193                         } else {
 194                                 minix_dirent *de = (minix_dirent *)p;
 195                                 namx = de->name;
 196                                 inumber = de->inode;
 197                         }
 198                         if (!inumber)
 199                                 continue;
 200                         if (namecompare(namelen, sbi->s_namelen, name, namx))
 201                                 goto found;
 202                 }
 203                 dir_put_page(page);
 204         }
 205         return NULL;
 206
 207 found:
 208         *res_page = page;
 209         return (minix_dirent *)p;
 210 }
 211
 212 int minix_add_link(struct dentry *dentry, struct inode *inode)
 213 {
 214         struct inode *dir = dentry->d_parent->d_inode;
 215         const char * name = dentry->d_name.name;
 216         int namelen = dentry->d_name.len;
 217         struct super_block * sb = dir->i_sb;
 218         struct minix_sb_info * sbi = minix_sb(sb);
 219         struct page *page = NULL;
 220         unsigned long npages = dir_pages(dir);
 221         unsigned long n;
 222         char *kaddr, *p;
 223         minix_dirent *de;
 224         minix3_dirent *de3;
 225         loff_t pos;
 226         int err;
 227         char *namx = NULL;
 228         __u32 inumber;
 229
 230         /*
 231          * We take care of directory expansion in the same loop
 232          * This code plays outside i_size, so it locks the page
 233          * to protect that region.
 234          */
 235         for (n = 0; n <= npages; n++) {
 236                 char *limit, *dir_end;
 237
 238                 page = dir_get_page(dir, n);
 239                 err = PTR_ERR(page);
 240                 if (IS_ERR(page))
 241                         goto out;
 242                 lock_page(page);
 243                 kaddr = (char*)page_address(page);
 244                 dir_end = kaddr + minix_last_byte(dir, n);
 245                 limit = kaddr + PAGE_CACHE_SIZE - sbi->s_dirsize;
 246                 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
 247                         de = (minix_dirent *)p;
 248                         de3 = (minix3_dirent *)p;
 249                         if (sbi->s_version == MINIX_V3) {
 250                                 namx = de3->name;
 251                                 inumber = de3->inode;
 252                         } else {
 253                                 namx = de->name;
 254                                 inumber = de->inode;
 255                         }
 256                         if (p == dir_end) {
 257                                 /* We hit i_size */
 258                                 if (sbi->s_version == MINIX_V3)
 259                                         de3->inode = 0;
 260                                 else
 261                                         de->inode = 0;
 262                                 goto got_it;
 263                         }
 264                         if (!inumber)
 265                                 goto got_it;
 266                         err = -EEXIST;
 267                         if (namecompare(namelen, sbi->s_namelen, name, namx))
 268                                 goto out_unlock;
 269                 }
 270                 unlock_page(page);
 271                 dir_put_page(page);
 272         }
 273         BUG();
 274         return -EINVAL;
 275
 276 got_it:
 277         pos = page_offset(page) + p - (char *)page_address(page);
 278         err = __minix_write_begin(NULL, page->mapping, pos, sbi->s_dirsize,
 279                                         AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
 280         if (err)
 281                 goto out_unlock;
 282         memcpy (namx, name, namelen);
 283         if (sbi->s_version == MINIX_V3) {
 284                 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 4);
 285                 de3->inode = inode->i_ino;
 286         } else {
 287                 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 2);
 288                 de->inode = inode->i_ino;
 289         }
 290         err = dir_commit_chunk(page, pos, sbi->s_dirsize);
 291         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
 292         mark_inode_dirty(dir);
 293 out_put:
 294         dir_put_page(page);
 295 out:
 296         return err;
 297 out_unlock:
 298         unlock_page(page);
 299         goto out_put;
 300 }
 301
 302 int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
 303 {
 304         struct address_space *mapping = page->mapping;
 305         struct inode *inode = (struct inode*)mapping->host;
 306         char *kaddr = page_address(page);
 307         loff_t pos = page_offset(page) + (char*)de - kaddr;
 308         struct minix_sb_info *sbi = minix_sb(inode->i_sb);
 309         unsigned len = sbi->s_dirsize;
 310         int err;
 311
 312         lock_page(page);
 313         err = __minix_write_begin(NULL, mapping, pos, len,
 314                                         AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
 315         if (err == 0) {
 316                 if (sbi->s_version == MINIX_V3)
 317                         ((minix3_dirent *) de)->inode = 0;
 318                 else
 319                         de->inode = 0;
 320                 err = dir_commit_chunk(page, pos, len);
 321         } else {
 322                 unlock_page(page);
 323         }
 324         dir_put_page(page);
 325         inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
 326         mark_inode_dirty(inode);
 327         return err;
 328 }
 329
 330 int minix_make_empty(struct inode *inode, struct inode *dir)
 331 {
 332         struct address_space *mapping = inode->i_mapping;
 333         struct page *page = grab_cache_page(mapping, 0);
 334         struct minix_sb_info *sbi = minix_sb(inode->i_sb);
 335         char *kaddr;
 336         int err;
 337
 338         if (!page)
 339                 return -ENOMEM;
 340         err = __minix_write_begin(NULL, mapping, 0, 2 * sbi->s_dirsize,
 341                                         AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
 342         if (err) {
 343                 unlock_page(page);
 344                 goto fail;
 345         }
 346
 347         kaddr = kmap_atomic(page, KM_USER0);
 348         memset(kaddr, 0, PAGE_CACHE_SIZE);
 349
 350         if (sbi->s_version == MINIX_V3) {
 351                 minix3_dirent *de3 = (minix3_dirent *)kaddr;
 352
 353                 de3->inode = inode->i_ino;
 354                 strcpy(de3->name, ".");
 355                 de3 = minix_next_entry(de3, sbi);
 356                 de3->inode = dir->i_ino;
 357                 strcpy(de3->name, "..");
 358         } else {
 359                 minix_dirent *de = (minix_dirent *)kaddr;
 360
 361                 de->inode = inode->i_ino;
 362                 strcpy(de->name, ".");
 363                 de = minix_next_entry(de, sbi);
 364                 de->inode = dir->i_ino;
 365                 strcpy(de->name, "..");
 366         }
 367         kunmap_atomic(kaddr, KM_USER0);
 368
 369         err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize);
 370 fail:
 371         page_cache_release(page);
 372         return err;
 373 }
 374
 375 /*
 376  * routine to check that the specified directory is empty (for rmdir)
 377  */
 378 int minix_empty_dir(struct inode * inode)
 379 {
 380         struct page *page = NULL;
 381         unsigned long i, npages = dir_pages(inode);
 382         struct minix_sb_info *sbi = minix_sb(inode->i_sb);
 383         char *name;
 384         __u32 inumber;
 385
 386         for (i = 0; i < npages; i++) {
 387                 char *p, *kaddr, *limit;
 388
 389                 page = dir_get_page(inode, i);
 390                 if (IS_ERR(page))
 391                         continue;
 392
 393                 kaddr = (char *)page_address(page);
 394                 limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize;
 395                 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
 396                         if (sbi->s_version == MINIX_V3) {
 397                                 minix3_dirent *de3 = (minix3_dirent *)p;
 398                                 name = de3->name;
 399                                 inumber = de3->inode;
 400                         } else {
 401                                 minix_dirent *de = (minix_dirent *)p;
 402                                 name = de->name;
 403                                 inumber = de->inode;
 404                         }
 405
 406                         if (inumber != 0) {
 407                                 /* check for . and .. */
 408                                 if (name[0] != '.')
 409                                         goto not_empty;
 410                                 if (!name[1]) {
 411                                         if (inumber != inode->i_ino)
 412                                                 goto not_empty;
 413                                 } else if (name[1] != '.')
 414                                         goto not_empty;
 415                                 else if (name[2])
 416                                         goto not_empty;
 417                         }
 418                 }
 419                 dir_put_page(page);
 420         }
 421         return 1;
 422
 423 not_empty:
 424         dir_put_page(page);
 425         return 0;
 426 }
 427
 428 /* Releases the page */
 429 void minix_set_link(struct minix_dir_entry *de, struct page *page,
 430         struct inode *inode)
 431 {
 432         struct address_space *mapping = page->mapping;
 433         struct inode *dir = mapping->host;
 434         struct minix_sb_info *sbi = minix_sb(dir->i_sb);
 435         loff_t pos = page_offset(page) +
 436                         (char *)de-(char*)page_address(page);
 437         int err;
 438
 439         lock_page(page);
 440
 441         err = __minix_write_begin(NULL, mapping, pos, sbi->s_dirsize,
 442                                         AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
 443         if (err == 0) {
 444                 if (sbi->s_version == MINIX_V3)
 445                         ((minix3_dirent *) de)->inode = inode->i_ino;
 446                 else
 447                         de->inode = inode->i_ino;
 448                 err = dir_commit_chunk(page, pos, sbi->s_dirsize);
 449         } else {
 450                 unlock_page(page);
 451         }
 452         dir_put_page(page);
 453         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
 454         mark_inode_dirty(dir);
 455 }
 456
 457 struct minix_dir_entry * minix_dotdot (struct inode *dir, struct page **p)
 458 {
 459         struct page *page = dir_get_page(dir, 0);
 460         struct minix_sb_info *sbi = minix_sb(dir->i_sb);
 461         struct minix_dir_entry *de = NULL;
 462
 463         if (!IS_ERR(page)) {
 464                 de = minix_next_entry(page_address(page), sbi);
 465                 *p = page;
 466         }
 467         return de;
 468 }
 469
 470 ino_t minix_inode_by_name(struct dentry *dentry)
 471 {
 472         struct page *page;
 473         struct minix_dir_entry *de = minix_find_entry(dentry, &page);
 474         ino_t res = 0;
 475
 476         if (de) {
 477                 struct address_space *mapping = page->mapping;
 478                 struct inode *inode = mapping->host;
 479                 struct minix_sb_info *sbi = minix_sb(inode->i_sb);
 480
 481                 if (sbi->s_version == MINIX_V3)
 482                         res = ((minix3_dirent *) de)->inode;
 483                 else
 484                         res = de->inode;
 485                 dir_put_page(page);
 486         }
 487         return res;
 488 }