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