Blame view
fs/nilfs2/dir.c
17 KB
2ba466d74 nilfs2: directory... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
/* * dir.c - NILFS directory entry operations * * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * |
4b420ab4e nilfs2: clean up ... |
16 |
* Modified for NILFS by Amagai Yoshiji. |
2ba466d74 nilfs2: directory... |
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
*/ /* * linux/fs/ext2/dir.c * * Copyright (C) 1992, 1993, 1994, 1995 * Remy Card (card@masi.ibp.fr) * Laboratoire MASI - Institut Blaise Pascal * Universite Pierre et Marie Curie (Paris VI) * * from * * linux/fs/minix/dir.c * * Copyright (C) 1991, 1992 Linus Torvalds * * ext2 directory handling functions * * Big-endian to little-endian byte-swapping/bitmaps by * David S. Miller (davem@caip.rutgers.edu), 1995 * * All code that works with directory layout had been switched to pagecache * and moved here. AV */ #include <linux/pagemap.h> |
2ba466d74 nilfs2: directory... |
42 43 |
#include "nilfs.h" #include "page.h" |
e63e88bc5 nilfs2: move ioct... |
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
static inline unsigned int nilfs_rec_len_from_disk(__le16 dlen) { unsigned int len = le16_to_cpu(dlen); #if (PAGE_SIZE >= 65536) if (len == NILFS_MAX_REC_LEN) return 1 << 16; #endif return len; } static inline __le16 nilfs_rec_len_to_disk(unsigned int len) { #if (PAGE_SIZE >= 65536) if (len == (1 << 16)) return cpu_to_le16(NILFS_MAX_REC_LEN); BUG_ON(len > (1 << 16)); #endif return cpu_to_le16(len); } |
2ba466d74 nilfs2: directory... |
65 66 67 68 |
/* * nilfs uses block-sized chunks. Arguably, sector-sized ones would be * more robust, but we have what we have */ |
0c6c44cb9 nilfs2: avoid bar... |
69 |
static inline unsigned int nilfs_chunk_size(struct inode *inode) |
2ba466d74 nilfs2: directory... |
70 71 72 73 74 75 76 |
{ return inode->i_sb->s_blocksize; } static inline void nilfs_put_page(struct page *page) { kunmap(page); |
09cbfeaf1 mm, fs: get rid o... |
77 |
put_page(page); |
2ba466d74 nilfs2: directory... |
78 |
} |
2ba466d74 nilfs2: directory... |
79 80 81 82 |
/* * Return the offset into page `page_nr' of the last valid * byte in that page, plus one. */ |
0c6c44cb9 nilfs2: avoid bar... |
83 |
static unsigned int nilfs_last_byte(struct inode *inode, unsigned long page_nr) |
2ba466d74 nilfs2: directory... |
84 |
{ |
0c6c44cb9 nilfs2: avoid bar... |
85 |
unsigned int last_byte = inode->i_size; |
2ba466d74 nilfs2: directory... |
86 |
|
09cbfeaf1 mm, fs: get rid o... |
87 88 89 |
last_byte -= page_nr << PAGE_SHIFT; if (last_byte > PAGE_SIZE) last_byte = PAGE_SIZE; |
2ba466d74 nilfs2: directory... |
90 91 |
return last_byte; } |
0c6c44cb9 nilfs2: avoid bar... |
92 93 |
static int nilfs_prepare_chunk(struct page *page, unsigned int from, unsigned int to) |
2ba466d74 nilfs2: directory... |
94 95 |
{ loff_t pos = page_offset(page) + from; |
4ad364ca1 nilfs2: add missi... |
96 |
|
6e1db88d5 introduce __block... |
97 |
return __block_write_begin(page, pos, to - from, nilfs_get_block); |
2ba466d74 nilfs2: directory... |
98 |
} |
2093abf9c nilfs2: change re... |
99 100 |
static void nilfs_commit_chunk(struct page *page, struct address_space *mapping, |
0c6c44cb9 nilfs2: avoid bar... |
101 |
unsigned int from, unsigned int to) |
2ba466d74 nilfs2: directory... |
102 103 |
{ struct inode *dir = mapping->host; |
2ba466d74 nilfs2: directory... |
104 |
loff_t pos = page_offset(page) + from; |
0c6c44cb9 nilfs2: avoid bar... |
105 106 |
unsigned int len = to - from; unsigned int nr_dirty, copied; |
2ba466d74 nilfs2: directory... |
107 108 109 110 |
int err; nr_dirty = nilfs_page_count_clean_buffers(page, from, to); copied = block_write_end(NULL, mapping, pos, len, len, page, NULL); |
58d55471c nilfs2: delete ma... |
111 |
if (pos + copied > dir->i_size) |
2ba466d74 nilfs2: directory... |
112 |
i_size_write(dir, pos + copied); |
2ba466d74 nilfs2: directory... |
113 114 |
if (IS_DIRSYNC(dir)) nilfs_set_transaction_flag(NILFS_TI_SYNC); |
bcbc8c648 nilfs2: do not pa... |
115 |
err = nilfs_set_file_dirty(dir, nr_dirty); |
2093abf9c nilfs2: change re... |
116 |
WARN_ON(err); /* do not happen */ |
2ba466d74 nilfs2: directory... |
117 |
unlock_page(page); |
2ba466d74 nilfs2: directory... |
118 |
} |
be5b82dbf make ext2_get_pag... |
119 |
static bool nilfs_check_page(struct page *page) |
2ba466d74 nilfs2: directory... |
120 121 122 |
{ struct inode *dir = page->mapping->host; struct super_block *sb = dir->i_sb; |
0c6c44cb9 nilfs2: avoid bar... |
123 |
unsigned int chunk_size = nilfs_chunk_size(dir); |
2ba466d74 nilfs2: directory... |
124 |
char *kaddr = page_address(page); |
0c6c44cb9 nilfs2: avoid bar... |
125 126 |
unsigned int offs, rec_len; unsigned int limit = PAGE_SIZE; |
2ba466d74 nilfs2: directory... |
127 128 |
struct nilfs_dir_entry *p; char *error; |
09cbfeaf1 mm, fs: get rid o... |
129 130 |
if ((dir->i_size >> PAGE_SHIFT) == page->index) { limit = dir->i_size & ~PAGE_MASK; |
2ba466d74 nilfs2: directory... |
131 132 133 134 135 136 137 |
if (limit & (chunk_size - 1)) goto Ebadsize; if (!limit) goto out; } for (offs = 0; offs <= limit - NILFS_DIR_REC_LEN(1); offs += rec_len) { p = (struct nilfs_dir_entry *)(kaddr + offs); |
6cda9fa25 nilfs2: avoid rec... |
138 |
rec_len = nilfs_rec_len_from_disk(p->rec_len); |
2ba466d74 nilfs2: directory... |
139 140 141 142 143 144 145 146 147 148 149 150 151 152 |
if (rec_len < NILFS_DIR_REC_LEN(1)) goto Eshort; if (rec_len & 3) goto Ealign; if (rec_len < NILFS_DIR_REC_LEN(p->name_len)) goto Enamelen; if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1)) goto Espan; } if (offs != limit) goto Eend; out: SetPageChecked(page); |
be5b82dbf make ext2_get_pag... |
153 |
return true; |
2ba466d74 nilfs2: directory... |
154 155 156 157 |
/* Too bad, we had an error */ Ebadsize: |
cae3d4ca6 nilfs2: hide func... |
158 |
nilfs_error(sb, |
2ba466d74 nilfs2: directory... |
159 |
"size of directory #%lu is not a multiple of chunk size", |
cae3d4ca6 nilfs2: hide func... |
160 |
dir->i_ino); |
2ba466d74 nilfs2: directory... |
161 162 163 164 165 166 167 168 169 170 171 172 173 |
goto fail; Eshort: error = "rec_len is smaller than minimal"; goto bad_entry; Ealign: error = "unaligned directory entry"; goto bad_entry; Enamelen: error = "rec_len is too small for name_len"; goto bad_entry; Espan: error = "directory entry across blocks"; bad_entry: |
cae3d4ca6 nilfs2: hide func... |
174 175 176 177 |
nilfs_error(sb, "bad entry in directory #%lu: %s - offset=%lu, inode=%lu, rec_len=%d, name_len=%d", dir->i_ino, error, (page->index << PAGE_SHIFT) + offs, (unsigned long)le64_to_cpu(p->inode), |
2ba466d74 nilfs2: directory... |
178 179 180 181 |
rec_len, p->name_len); goto fail; Eend: p = (struct nilfs_dir_entry *)(kaddr + offs); |
cae3d4ca6 nilfs2: hide func... |
182 183 184 185 |
nilfs_error(sb, "entry in directory #%lu spans the page boundary offset=%lu, inode=%lu", dir->i_ino, (page->index << PAGE_SHIFT) + offs, (unsigned long)le64_to_cpu(p->inode)); |
2ba466d74 nilfs2: directory... |
186 |
fail: |
2ba466d74 nilfs2: directory... |
187 |
SetPageError(page); |
be5b82dbf make ext2_get_pag... |
188 |
return false; |
2ba466d74 nilfs2: directory... |
189 190 191 192 193 |
} static struct page *nilfs_get_page(struct inode *dir, unsigned long n) { struct address_space *mapping = dir->i_mapping; |
c28e69d93 nilfs2: simplify ... |
194 |
struct page *page = read_mapping_page(mapping, n, NULL); |
2ba466d74 nilfs2: directory... |
195 |
if (!IS_ERR(page)) { |
2ba466d74 nilfs2: directory... |
196 |
kmap(page); |
be5b82dbf make ext2_get_pag... |
197 198 199 200 |
if (unlikely(!PageChecked(page))) { if (PageError(page) || !nilfs_check_page(page)) goto fail; } |
2ba466d74 nilfs2: directory... |
201 202 203 204 205 206 207 208 209 210 211 212 213 214 |
} return page; fail: nilfs_put_page(page); return ERR_PTR(-EIO); } /* * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure. * * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller. */ static int |
072f98b46 nilfs: sanitize c... |
215 |
nilfs_match(int len, const unsigned char *name, struct nilfs_dir_entry *de) |
2ba466d74 nilfs2: directory... |
216 217 218 219 220 221 222 223 224 225 226 227 228 |
{ if (len != de->name_len) return 0; if (!de->inode) return 0; return !memcmp(name, de->name, len); } /* * p is at least 6 bytes before the end of page */ static struct nilfs_dir_entry *nilfs_next_entry(struct nilfs_dir_entry *p) { |
6cda9fa25 nilfs2: avoid rec... |
229 230 |
return (struct nilfs_dir_entry *)((char *)p + nilfs_rec_len_from_disk(p->rec_len)); |
2ba466d74 nilfs2: directory... |
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 |
} static unsigned char nilfs_filetype_table[NILFS_FT_MAX] = { [NILFS_FT_UNKNOWN] = DT_UNKNOWN, [NILFS_FT_REG_FILE] = DT_REG, [NILFS_FT_DIR] = DT_DIR, [NILFS_FT_CHRDEV] = DT_CHR, [NILFS_FT_BLKDEV] = DT_BLK, [NILFS_FT_FIFO] = DT_FIFO, [NILFS_FT_SOCK] = DT_SOCK, [NILFS_FT_SYMLINK] = DT_LNK, }; #define S_SHIFT 12 static unsigned char nilfs_type_by_mode[S_IFMT >> S_SHIFT] = { [S_IFREG >> S_SHIFT] = NILFS_FT_REG_FILE, [S_IFDIR >> S_SHIFT] = NILFS_FT_DIR, [S_IFCHR >> S_SHIFT] = NILFS_FT_CHRDEV, [S_IFBLK >> S_SHIFT] = NILFS_FT_BLKDEV, [S_IFIFO >> S_SHIFT] = NILFS_FT_FIFO, [S_IFSOCK >> S_SHIFT] = NILFS_FT_SOCK, [S_IFLNK >> S_SHIFT] = NILFS_FT_SYMLINK, }; static void nilfs_set_de_type(struct nilfs_dir_entry *de, struct inode *inode) { |
c6e49e3f2 nilfs: propagate ... |
259 |
umode_t mode = inode->i_mode; |
2ba466d74 nilfs2: directory... |
260 261 262 |
de->file_type = nilfs_type_by_mode[(mode & S_IFMT)>>S_SHIFT]; } |
1616abe84 [readdir] convert... |
263 |
static int nilfs_readdir(struct file *file, struct dir_context *ctx) |
2ba466d74 nilfs2: directory... |
264 |
{ |
1616abe84 [readdir] convert... |
265 266 |
loff_t pos = ctx->pos; struct inode *inode = file_inode(file); |
2ba466d74 nilfs2: directory... |
267 |
struct super_block *sb = inode->i_sb; |
09cbfeaf1 mm, fs: get rid o... |
268 269 |
unsigned int offset = pos & ~PAGE_MASK; unsigned long n = pos >> PAGE_SHIFT; |
2ba466d74 nilfs2: directory... |
270 |
unsigned long npages = dir_pages(inode); |
2ba466d74 nilfs2: directory... |
271 272 |
if (pos > inode->i_size - NILFS_DIR_REC_LEN(1)) |
1616abe84 [readdir] convert... |
273 |
return 0; |
2ba466d74 nilfs2: directory... |
274 275 276 277 278 279 280 |
for ( ; n < npages; n++, offset = 0) { char *kaddr, *limit; struct nilfs_dir_entry *de; struct page *page = nilfs_get_page(inode, n); if (IS_ERR(page)) { |
cae3d4ca6 nilfs2: hide func... |
281 |
nilfs_error(sb, "bad page in #%lu", inode->i_ino); |
09cbfeaf1 mm, fs: get rid o... |
282 |
ctx->pos += PAGE_SIZE - offset; |
1616abe84 [readdir] convert... |
283 |
return -EIO; |
2ba466d74 nilfs2: directory... |
284 285 286 287 288 289 290 |
} kaddr = page_address(page); de = (struct nilfs_dir_entry *)(kaddr + offset); limit = kaddr + nilfs_last_byte(inode, n) - NILFS_DIR_REC_LEN(1); for ( ; (char *)de <= limit; de = nilfs_next_entry(de)) { if (de->rec_len == 0) { |
cae3d4ca6 nilfs2: hide func... |
291 |
nilfs_error(sb, "zero-length directory entry"); |
2ba466d74 nilfs2: directory... |
292 |
nilfs_put_page(page); |
1616abe84 [readdir] convert... |
293 |
return -EIO; |
2ba466d74 nilfs2: directory... |
294 295 |
} if (de->inode) { |
1616abe84 [readdir] convert... |
296 |
unsigned char t; |
2ba466d74 nilfs2: directory... |
297 |
|
1616abe84 [readdir] convert... |
298 299 300 301 |
if (de->file_type < NILFS_FT_MAX) t = nilfs_filetype_table[de->file_type]; else t = DT_UNKNOWN; |
2ba466d74 nilfs2: directory... |
302 |
|
1616abe84 [readdir] convert... |
303 304 |
if (!dir_emit(ctx, de->name, de->name_len, le64_to_cpu(de->inode), t)) { |
2ba466d74 nilfs2: directory... |
305 |
nilfs_put_page(page); |
1616abe84 [readdir] convert... |
306 |
return 0; |
2ba466d74 nilfs2: directory... |
307 308 |
} } |
1616abe84 [readdir] convert... |
309 |
ctx->pos += nilfs_rec_len_from_disk(de->rec_len); |
2ba466d74 nilfs2: directory... |
310 311 312 |
} nilfs_put_page(page); } |
1616abe84 [readdir] convert... |
313 |
return 0; |
2ba466d74 nilfs2: directory... |
314 315 316 317 318 319 320 321 322 323 324 |
} /* * nilfs_find_entry() * * finds an entry in the specified directory with the wanted name. It * returns the page in which the entry was found, and the entry itself * (as a parameter - res_dir). Page is returned mapped and unlocked. * Entry is guaranteed to be valid. */ struct nilfs_dir_entry * |
0319003d0 nilfs really shou... |
325 |
nilfs_find_entry(struct inode *dir, const struct qstr *qstr, |
2ba466d74 nilfs2: directory... |
326 327 |
struct page **res_page) { |
0319003d0 nilfs really shou... |
328 329 |
const unsigned char *name = qstr->name; int namelen = qstr->len; |
0c6c44cb9 nilfs2: avoid bar... |
330 |
unsigned int reclen = NILFS_DIR_REC_LEN(namelen); |
2ba466d74 nilfs2: directory... |
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 |
unsigned long start, n; unsigned long npages = dir_pages(dir); struct page *page = NULL; struct nilfs_inode_info *ei = NILFS_I(dir); struct nilfs_dir_entry *de; if (npages == 0) goto out; /* OFFSET_CACHE */ *res_page = NULL; start = ei->i_dir_start_lookup; if (start >= npages) start = 0; n = start; do { char *kaddr; |
4ad364ca1 nilfs2: add missi... |
349 |
|
2ba466d74 nilfs2: directory... |
350 351 352 353 354 355 356 |
page = nilfs_get_page(dir, n); if (!IS_ERR(page)) { kaddr = page_address(page); de = (struct nilfs_dir_entry *)kaddr; kaddr += nilfs_last_byte(dir, n) - reclen; while ((char *) de <= kaddr) { if (de->rec_len == 0) { |
cae3d4ca6 nilfs2: hide func... |
357 |
nilfs_error(dir->i_sb, |
2ba466d74 nilfs2: directory... |
358 359 360 361 362 363 364 365 366 367 368 369 370 |
"zero-length directory entry"); nilfs_put_page(page); goto out; } if (nilfs_match(namelen, name, de)) goto found; de = nilfs_next_entry(de); } nilfs_put_page(page); } if (++n >= npages) n = 0; /* next page is past the blocks we've got */ |
09cbfeaf1 mm, fs: get rid o... |
371 |
if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) { |
cae3d4ca6 nilfs2: hide func... |
372 |
nilfs_error(dir->i_sb, |
1621562b6 nilfs2: fix typo ... |
373 |
"dir %lu size %lld exceeds block count %llu", |
2ba466d74 nilfs2: directory... |
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 |
dir->i_ino, dir->i_size, (unsigned long long)dir->i_blocks); goto out; } } while (n != start); out: return NULL; found: *res_page = page; ei->i_dir_start_lookup = n; return de; } struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct page **p) { struct page *page = nilfs_get_page(dir, 0); struct nilfs_dir_entry *de = NULL; if (!IS_ERR(page)) { de = nilfs_next_entry( (struct nilfs_dir_entry *)page_address(page)); *p = page; } return de; } |
0319003d0 nilfs really shou... |
400 |
ino_t nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr) |
2ba466d74 nilfs2: directory... |
401 402 403 404 |
{ ino_t res = 0; struct nilfs_dir_entry *de; struct page *page; |
0319003d0 nilfs really shou... |
405 |
de = nilfs_find_entry(dir, qstr, &page); |
2ba466d74 nilfs2: directory... |
406 407 408 |
if (de) { res = le64_to_cpu(de->inode); kunmap(page); |
09cbfeaf1 mm, fs: get rid o... |
409 |
put_page(page); |
2ba466d74 nilfs2: directory... |
410 411 412 413 414 415 416 417 |
} return res; } /* Releases the page */ void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de, struct page *page, struct inode *inode) { |
0c6c44cb9 nilfs2: avoid bar... |
418 419 |
unsigned int from = (char *)de - (char *)page_address(page); unsigned int to = from + nilfs_rec_len_from_disk(de->rec_len); |
2ba466d74 nilfs2: directory... |
420 421 422 423 |
struct address_space *mapping = page->mapping; int err; lock_page(page); |
f4e420dc4 clean up write_be... |
424 |
err = nilfs_prepare_chunk(page, from, to); |
2ba466d74 nilfs2: directory... |
425 426 427 |
BUG_ON(err); de->inode = cpu_to_le64(inode->i_ino); nilfs_set_de_type(de, inode); |
2093abf9c nilfs2: change re... |
428 |
nilfs_commit_chunk(page, mapping, from, to); |
2ba466d74 nilfs2: directory... |
429 |
nilfs_put_page(page); |
078cd8279 fs: Replace CURRE... |
430 |
dir->i_mtime = dir->i_ctime = current_time(dir); |
2ba466d74 nilfs2: directory... |
431 432 433 434 435 436 437 |
} /* * Parent is locked. */ int nilfs_add_link(struct dentry *dentry, struct inode *inode) { |
2b0143b5c VFS: normal files... |
438 |
struct inode *dir = d_inode(dentry->d_parent); |
072f98b46 nilfs: sanitize c... |
439 |
const unsigned char *name = dentry->d_name.name; |
2ba466d74 nilfs2: directory... |
440 |
int namelen = dentry->d_name.len; |
0c6c44cb9 nilfs2: avoid bar... |
441 442 |
unsigned int chunk_size = nilfs_chunk_size(dir); unsigned int reclen = NILFS_DIR_REC_LEN(namelen); |
2ba466d74 nilfs2: directory... |
443 444 445 446 447 448 |
unsigned short rec_len, name_len; struct page *page = NULL; struct nilfs_dir_entry *de; unsigned long npages = dir_pages(dir); unsigned long n; char *kaddr; |
0c6c44cb9 nilfs2: avoid bar... |
449 |
unsigned int from, to; |
2ba466d74 nilfs2: directory... |
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 |
int err; /* * We take care of directory expansion in the same loop. * This code plays outside i_size, so it locks the page * to protect that region. */ for (n = 0; n <= npages; n++) { char *dir_end; page = nilfs_get_page(dir, n); err = PTR_ERR(page); if (IS_ERR(page)) goto out; lock_page(page); kaddr = page_address(page); dir_end = kaddr + nilfs_last_byte(dir, n); de = (struct nilfs_dir_entry *)kaddr; |
09cbfeaf1 mm, fs: get rid o... |
468 |
kaddr += PAGE_SIZE - reclen; |
2ba466d74 nilfs2: directory... |
469 470 471 472 473 |
while ((char *)de <= kaddr) { if ((char *)de == dir_end) { /* We hit i_size */ name_len = 0; rec_len = chunk_size; |
6cda9fa25 nilfs2: avoid rec... |
474 |
de->rec_len = nilfs_rec_len_to_disk(chunk_size); |
2ba466d74 nilfs2: directory... |
475 476 477 478 |
de->inode = 0; goto got_it; } if (de->rec_len == 0) { |
cae3d4ca6 nilfs2: hide func... |
479 |
nilfs_error(dir->i_sb, |
2ba466d74 nilfs2: directory... |
480 481 482 483 484 485 486 487 |
"zero-length directory entry"); err = -EIO; goto out_unlock; } err = -EEXIST; if (nilfs_match(namelen, name, de)) goto out_unlock; name_len = NILFS_DIR_REC_LEN(de->name_len); |
6cda9fa25 nilfs2: avoid rec... |
488 |
rec_len = nilfs_rec_len_from_disk(de->rec_len); |
2ba466d74 nilfs2: directory... |
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 |
if (!de->inode && rec_len >= reclen) goto got_it; if (rec_len >= name_len + reclen) goto got_it; de = (struct nilfs_dir_entry *)((char *)de + rec_len); } unlock_page(page); nilfs_put_page(page); } BUG(); return -EINVAL; got_it: from = (char *)de - (char *)page_address(page); to = from + rec_len; |
f4e420dc4 clean up write_be... |
504 |
err = nilfs_prepare_chunk(page, from, to); |
2ba466d74 nilfs2: directory... |
505 506 507 508 509 510 |
if (err) goto out_unlock; if (de->inode) { struct nilfs_dir_entry *de1; de1 = (struct nilfs_dir_entry *)((char *)de + name_len); |
6cda9fa25 nilfs2: avoid rec... |
511 512 |
de1->rec_len = nilfs_rec_len_to_disk(rec_len - name_len); de->rec_len = nilfs_rec_len_to_disk(name_len); |
2ba466d74 nilfs2: directory... |
513 514 515 516 517 518 |
de = de1; } de->name_len = namelen; memcpy(de->name, name, namelen); de->inode = cpu_to_le64(inode->i_ino); nilfs_set_de_type(de, inode); |
2093abf9c nilfs2: change re... |
519 |
nilfs_commit_chunk(page, page->mapping, from, to); |
078cd8279 fs: Replace CURRE... |
520 |
dir->i_mtime = dir->i_ctime = current_time(dir); |
abdb318b7 nilfs2: replace m... |
521 |
nilfs_mark_inode_dirty(dir); |
2ba466d74 nilfs2: directory... |
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 |
/* OFFSET_CACHE */ out_put: nilfs_put_page(page); out: return err; out_unlock: unlock_page(page); goto out_put; } /* * nilfs_delete_entry deletes a directory entry by merging it with the * previous entry. Page is up-to-date. Releases the page. */ int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page) { struct address_space *mapping = page->mapping; struct inode *inode = mapping->host; char *kaddr = page_address(page); |
0c6c44cb9 nilfs2: avoid bar... |
541 542 |
unsigned int from, to; struct nilfs_dir_entry *de, *pde = NULL; |
2ba466d74 nilfs2: directory... |
543 |
int err; |
0c6c44cb9 nilfs2: avoid bar... |
544 545 546 |
from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1); to = ((char *)dir - kaddr) + nilfs_rec_len_from_disk(dir->rec_len); de = (struct nilfs_dir_entry *)(kaddr + from); |
2ba466d74 nilfs2: directory... |
547 548 |
while ((char *)de < (char *)dir) { if (de->rec_len == 0) { |
cae3d4ca6 nilfs2: hide func... |
549 |
nilfs_error(inode->i_sb, |
2ba466d74 nilfs2: directory... |
550 551 552 553 554 555 556 557 558 559 |
"zero-length directory entry"); err = -EIO; goto out; } pde = de; de = nilfs_next_entry(de); } if (pde) from = (char *)pde - (char *)page_address(page); lock_page(page); |
f4e420dc4 clean up write_be... |
560 |
err = nilfs_prepare_chunk(page, from, to); |
2ba466d74 nilfs2: directory... |
561 562 |
BUG_ON(err); if (pde) |
6cda9fa25 nilfs2: avoid rec... |
563 |
pde->rec_len = nilfs_rec_len_to_disk(to - from); |
2ba466d74 nilfs2: directory... |
564 |
dir->inode = 0; |
2093abf9c nilfs2: change re... |
565 |
nilfs_commit_chunk(page, mapping, from, to); |
078cd8279 fs: Replace CURRE... |
566 |
inode->i_ctime = inode->i_mtime = current_time(inode); |
2ba466d74 nilfs2: directory... |
567 568 569 570 571 572 573 574 575 576 577 578 |
out: nilfs_put_page(page); return err; } /* * Set the first fragment of directory. */ int nilfs_make_empty(struct inode *inode, struct inode *parent) { struct address_space *mapping = inode->i_mapping; struct page *page = grab_cache_page(mapping, 0); |
0c6c44cb9 nilfs2: avoid bar... |
579 |
unsigned int chunk_size = nilfs_chunk_size(inode); |
2ba466d74 nilfs2: directory... |
580 581 582 583 584 585 |
struct nilfs_dir_entry *de; int err; void *kaddr; if (!page) return -ENOMEM; |
f4e420dc4 clean up write_be... |
586 |
err = nilfs_prepare_chunk(page, 0, chunk_size); |
2ba466d74 nilfs2: directory... |
587 588 589 590 |
if (unlikely(err)) { unlock_page(page); goto fail; } |
7b9c0976a nilfs2: remove th... |
591 |
kaddr = kmap_atomic(page); |
2ba466d74 nilfs2: directory... |
592 593 594 |
memset(kaddr, 0, chunk_size); de = (struct nilfs_dir_entry *)kaddr; de->name_len = 1; |
6cda9fa25 nilfs2: avoid rec... |
595 |
de->rec_len = nilfs_rec_len_to_disk(NILFS_DIR_REC_LEN(1)); |
2ba466d74 nilfs2: directory... |
596 597 598 599 600 601 |
memcpy(de->name, ".\0\0", 4); de->inode = cpu_to_le64(inode->i_ino); nilfs_set_de_type(de, inode); de = (struct nilfs_dir_entry *)(kaddr + NILFS_DIR_REC_LEN(1)); de->name_len = 2; |
6cda9fa25 nilfs2: avoid rec... |
602 |
de->rec_len = nilfs_rec_len_to_disk(chunk_size - NILFS_DIR_REC_LEN(1)); |
2ba466d74 nilfs2: directory... |
603 604 605 |
de->inode = cpu_to_le64(parent->i_ino); memcpy(de->name, "..\0", 4); nilfs_set_de_type(de, inode); |
7b9c0976a nilfs2: remove th... |
606 |
kunmap_atomic(kaddr); |
2093abf9c nilfs2: change re... |
607 |
nilfs_commit_chunk(page, mapping, 0, chunk_size); |
2ba466d74 nilfs2: directory... |
608 |
fail: |
09cbfeaf1 mm, fs: get rid o... |
609 |
put_page(page); |
2ba466d74 nilfs2: directory... |
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 |
return err; } /* * routine to check that the specified directory is empty (for rmdir) */ int nilfs_empty_dir(struct inode *inode) { struct page *page = NULL; unsigned long i, npages = dir_pages(inode); for (i = 0; i < npages; i++) { char *kaddr; struct nilfs_dir_entry *de; page = nilfs_get_page(inode, i); if (IS_ERR(page)) continue; kaddr = page_address(page); de = (struct nilfs_dir_entry *)kaddr; kaddr += nilfs_last_byte(inode, i) - NILFS_DIR_REC_LEN(1); while ((char *)de <= kaddr) { if (de->rec_len == 0) { |
cae3d4ca6 nilfs2: hide func... |
635 |
nilfs_error(inode->i_sb, |
06f4abf6c nilfs2: do not em... |
636 637 |
"zero-length directory entry (kaddr=%p, de=%p)", kaddr, de); |
2ba466d74 nilfs2: directory... |
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 |
goto not_empty; } if (de->inode != 0) { /* check for . and .. */ if (de->name[0] != '.') goto not_empty; if (de->name_len > 2) goto not_empty; if (de->name_len < 2) { if (de->inode != cpu_to_le64(inode->i_ino)) goto not_empty; } else if (de->name[1] != '.') goto not_empty; } de = nilfs_next_entry(de); } nilfs_put_page(page); } return 1; not_empty: nilfs_put_page(page); return 0; } |
828c09509 const: constify r... |
663 |
const struct file_operations nilfs_dir_operations = { |
2ba466d74 nilfs2: directory... |
664 665 |
.llseek = generic_file_llseek, .read = generic_read_dir, |
c51da20c4 more trivial ->it... |
666 |
.iterate_shared = nilfs_readdir, |
7a9461939 nilfs2: use unloc... |
667 |
.unlocked_ioctl = nilfs_ioctl, |
2ba466d74 nilfs2: directory... |
668 |
#ifdef CONFIG_COMPAT |
828b1c50a nilfs2: add compa... |
669 |
.compat_ioctl = nilfs_compat_ioctl, |
2ba466d74 nilfs2: directory... |
670 671 672 673 |
#endif /* CONFIG_COMPAT */ .fsync = nilfs_sync_file, }; |