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