fs/minix/dir.c

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