Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * linux/fs/sysv/dir.c | |
4 | * | |
5 | * minix/dir.c | |
6 | * Copyright (C) 1991, 1992 Linus Torvalds | |
7 | * | |
8 | * coh/dir.c | |
9 | * Copyright (C) 1993 Pascal Haible, Bruno Haible | |
10 | * | |
11 | * sysv/dir.c | |
12 | * Copyright (C) 1993 Bruno Haible | |
13 | * | |
14 | * SystemV/Coherent directory handling functions | |
15 | */ | |
16 | ||
17 | #include <linux/pagemap.h> | |
18 | #include <linux/highmem.h> | |
26a6441a | 19 | #include <linux/swap.h> |
1da177e4 LT |
20 | #include "sysv.h" |
21 | ||
80886298 | 22 | static int sysv_readdir(struct file *, struct dir_context *); |
1da177e4 | 23 | |
4b6f5d20 | 24 | const struct file_operations sysv_dir_operations = { |
5ac3455a | 25 | .llseek = generic_file_llseek, |
1da177e4 | 26 | .read = generic_read_dir, |
3b0a3c1a | 27 | .iterate_shared = sysv_readdir, |
1b061d92 | 28 | .fsync = generic_file_fsync, |
1da177e4 LT |
29 | }; |
30 | ||
c26ddc49 | 31 | inline void dir_put_page(struct page *page) |
1da177e4 LT |
32 | { |
33 | kunmap(page); | |
09cbfeaf | 34 | put_page(page); |
1da177e4 LT |
35 | } |
36 | ||
4309093e | 37 | static void dir_commit_chunk(struct page *page, loff_t pos, unsigned len) |
1da177e4 | 38 | { |
26a6441a NP |
39 | struct address_space *mapping = page->mapping; |
40 | struct inode *dir = mapping->host; | |
1da177e4 | 41 | |
26a6441a NP |
42 | block_write_end(NULL, mapping, pos, len, len, page, NULL); |
43 | if (pos+len > dir->i_size) { | |
44 | i_size_write(dir, pos+len); | |
45 | mark_inode_dirty(dir); | |
46 | } | |
4309093e CH |
47 | unlock_page(page); |
48 | } | |
49 | ||
50 | static int sysv_handle_dirsync(struct inode *dir) | |
51 | { | |
52 | int err; | |
53 | ||
54 | err = filemap_write_and_wait(dir->i_mapping); | |
55 | if (!err) | |
56 | err = sync_inode_metadata(dir, 1); | |
1da177e4 LT |
57 | return err; |
58 | } | |
59 | ||
8dd6c7b2 | 60 | static void *dir_get_page(struct inode *dir, unsigned long n, struct page **p) |
1da177e4 LT |
61 | { |
62 | struct address_space *mapping = dir->i_mapping; | |
090d2b18 | 63 | struct page *page = read_mapping_page(mapping, n, NULL); |
8dd6c7b2 FDF |
64 | if (IS_ERR(page)) |
65 | return ERR_CAST(page); | |
66 | kmap(page); | |
67 | *p = page; | |
68 | return page_address(page); | |
1da177e4 LT |
69 | } |
70 | ||
80886298 | 71 | static int sysv_readdir(struct file *file, struct dir_context *ctx) |
1da177e4 | 72 | { |
80886298 AV |
73 | unsigned long pos = ctx->pos; |
74 | struct inode *inode = file_inode(file); | |
1da177e4 | 75 | struct super_block *sb = inode->i_sb; |
1da177e4 | 76 | unsigned long npages = dir_pages(inode); |
80886298 AV |
77 | unsigned offset; |
78 | unsigned long n; | |
1da177e4 | 79 | |
80886298 | 80 | ctx->pos = pos = (pos + SYSV_DIRSIZE-1) & ~(SYSV_DIRSIZE-1); |
1da177e4 | 81 | if (pos >= inode->i_size) |
80886298 AV |
82 | return 0; |
83 | ||
09cbfeaf KS |
84 | offset = pos & ~PAGE_MASK; |
85 | n = pos >> PAGE_SHIFT; | |
1da177e4 LT |
86 | |
87 | for ( ; n < npages; n++, offset = 0) { | |
88 | char *kaddr, *limit; | |
89 | struct sysv_dir_entry *de; | |
8dd6c7b2 | 90 | struct page *page; |
1da177e4 | 91 | |
8dd6c7b2 FDF |
92 | kaddr = dir_get_page(inode, n, &page); |
93 | if (IS_ERR(kaddr)) | |
1da177e4 | 94 | continue; |
1da177e4 | 95 | de = (struct sysv_dir_entry *)(kaddr+offset); |
09cbfeaf | 96 | limit = kaddr + PAGE_SIZE - SYSV_DIRSIZE; |
80886298 | 97 | for ( ;(char*)de <= limit; de++, ctx->pos += sizeof(*de)) { |
1da177e4 | 98 | char *name = de->name; |
1da177e4 LT |
99 | |
100 | if (!de->inode) | |
101 | continue; | |
102 | ||
80886298 | 103 | if (!dir_emit(ctx, name, strnlen(name,SYSV_NAMELEN), |
1da177e4 | 104 | fs16_to_cpu(SYSV_SB(sb), de->inode), |
80886298 | 105 | DT_UNKNOWN)) { |
1da177e4 | 106 | dir_put_page(page); |
80886298 | 107 | return 0; |
1da177e4 LT |
108 | } |
109 | } | |
110 | dir_put_page(page); | |
111 | } | |
1da177e4 LT |
112 | return 0; |
113 | } | |
114 | ||
115 | /* compare strings: name[0..len-1] (not zero-terminated) and | |
116 | * buffer[0..] (filled with zeroes up to buffer[0..maxlen-1]) | |
117 | */ | |
118 | static inline int namecompare(int len, int maxlen, | |
119 | const char * name, const char * buffer) | |
120 | { | |
121 | if (len < maxlen && buffer[len]) | |
122 | return 0; | |
123 | return !memcmp(name, buffer, len); | |
124 | } | |
125 | ||
126 | /* | |
127 | * sysv_find_entry() | |
128 | * | |
129 | * finds an entry in the specified directory with the wanted name. It | |
130 | * returns the cache buffer in which the entry was found, and the entry | |
131 | * itself (as a parameter - res_dir). It does NOT read the inode of the | |
132 | * entry - you'll have to do that yourself if you want to. | |
133 | */ | |
134 | struct sysv_dir_entry *sysv_find_entry(struct dentry *dentry, struct page **res_page) | |
135 | { | |
136 | const char * name = dentry->d_name.name; | |
137 | int namelen = dentry->d_name.len; | |
2b0143b5 | 138 | struct inode * dir = d_inode(dentry->d_parent); |
1da177e4 LT |
139 | unsigned long start, n; |
140 | unsigned long npages = dir_pages(dir); | |
141 | struct page *page = NULL; | |
142 | struct sysv_dir_entry *de; | |
143 | ||
144 | *res_page = NULL; | |
145 | ||
146 | start = SYSV_I(dir)->i_dir_start_lookup; | |
147 | if (start >= npages) | |
148 | start = 0; | |
149 | n = start; | |
150 | ||
151 | do { | |
8dd6c7b2 FDF |
152 | char *kaddr = dir_get_page(dir, n, &page); |
153 | ||
154 | if (!IS_ERR(kaddr)) { | |
155 | de = (struct sysv_dir_entry *)kaddr; | |
09cbfeaf | 156 | kaddr += PAGE_SIZE - SYSV_DIRSIZE; |
1da177e4 LT |
157 | for ( ; (char *) de <= kaddr ; de++) { |
158 | if (!de->inode) | |
159 | continue; | |
160 | if (namecompare(namelen, SYSV_NAMELEN, | |
161 | name, de->name)) | |
162 | goto found; | |
163 | } | |
404e7812 | 164 | dir_put_page(page); |
1da177e4 | 165 | } |
1da177e4 LT |
166 | |
167 | if (++n >= npages) | |
168 | n = 0; | |
169 | } while (n != start); | |
170 | ||
171 | return NULL; | |
172 | ||
173 | found: | |
174 | SYSV_I(dir)->i_dir_start_lookup = n; | |
175 | *res_page = page; | |
176 | return de; | |
177 | } | |
178 | ||
179 | int sysv_add_link(struct dentry *dentry, struct inode *inode) | |
180 | { | |
2b0143b5 | 181 | struct inode *dir = d_inode(dentry->d_parent); |
1da177e4 LT |
182 | const char * name = dentry->d_name.name; |
183 | int namelen = dentry->d_name.len; | |
184 | struct page *page = NULL; | |
185 | struct sysv_dir_entry * de; | |
186 | unsigned long npages = dir_pages(dir); | |
187 | unsigned long n; | |
188 | char *kaddr; | |
26a6441a | 189 | loff_t pos; |
1da177e4 LT |
190 | int err; |
191 | ||
192 | /* We take care of directory expansion in the same loop */ | |
193 | for (n = 0; n <= npages; n++) { | |
8dd6c7b2 FDF |
194 | kaddr = dir_get_page(dir, n, &page); |
195 | if (IS_ERR(kaddr)) | |
196 | return PTR_ERR(kaddr); | |
1da177e4 | 197 | de = (struct sysv_dir_entry *)kaddr; |
09cbfeaf | 198 | kaddr += PAGE_SIZE - SYSV_DIRSIZE; |
1da177e4 LT |
199 | while ((char *)de <= kaddr) { |
200 | if (!de->inode) | |
201 | goto got_it; | |
202 | err = -EEXIST; | |
203 | if (namecompare(namelen, SYSV_NAMELEN, name, de->name)) | |
204 | goto out_page; | |
205 | de++; | |
206 | } | |
207 | dir_put_page(page); | |
208 | } | |
209 | BUG(); | |
210 | return -EINVAL; | |
211 | ||
212 | got_it: | |
4bb1a137 | 213 | pos = page_offset(page) + offset_in_page(de); |
1da177e4 | 214 | lock_page(page); |
f4e420dc | 215 | err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE); |
1da177e4 LT |
216 | if (err) |
217 | goto out_unlock; | |
218 | memcpy (de->name, name, namelen); | |
219 | memset (de->name + namelen, 0, SYSV_DIRSIZE - namelen - 2); | |
220 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); | |
4309093e | 221 | dir_commit_chunk(page, pos, SYSV_DIRSIZE); |
02027d42 | 222 | dir->i_mtime = dir->i_ctime = current_time(dir); |
1da177e4 | 223 | mark_inode_dirty(dir); |
4309093e | 224 | err = sysv_handle_dirsync(dir); |
1da177e4 LT |
225 | out_page: |
226 | dir_put_page(page); | |
1da177e4 LT |
227 | return err; |
228 | out_unlock: | |
229 | unlock_page(page); | |
230 | goto out_page; | |
231 | } | |
232 | ||
233 | int sysv_delete_entry(struct sysv_dir_entry *de, struct page *page) | |
234 | { | |
f4e420dc | 235 | struct inode *inode = page->mapping->host; |
4bb1a137 | 236 | loff_t pos = page_offset(page) + offset_in_page(de); |
1da177e4 LT |
237 | int err; |
238 | ||
239 | lock_page(page); | |
f4e420dc | 240 | err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE); |
d6735bfc | 241 | BUG_ON(err); |
1da177e4 | 242 | de->inode = 0; |
4309093e | 243 | dir_commit_chunk(page, pos, SYSV_DIRSIZE); |
1da177e4 | 244 | dir_put_page(page); |
02027d42 | 245 | inode->i_ctime = inode->i_mtime = current_time(inode); |
1da177e4 | 246 | mark_inode_dirty(inode); |
4309093e | 247 | return sysv_handle_dirsync(inode); |
1da177e4 LT |
248 | } |
249 | ||
250 | int sysv_make_empty(struct inode *inode, struct inode *dir) | |
251 | { | |
f4e420dc | 252 | struct page *page = grab_cache_page(inode->i_mapping, 0); |
1da177e4 LT |
253 | struct sysv_dir_entry * de; |
254 | char *base; | |
255 | int err; | |
256 | ||
257 | if (!page) | |
258 | return -ENOMEM; | |
f4e420dc | 259 | err = sysv_prepare_chunk(page, 0, 2 * SYSV_DIRSIZE); |
1da177e4 LT |
260 | if (err) { |
261 | unlock_page(page); | |
262 | goto fail; | |
263 | } | |
26a6441a | 264 | kmap(page); |
1da177e4 LT |
265 | |
266 | base = (char*)page_address(page); | |
09cbfeaf | 267 | memset(base, 0, PAGE_SIZE); |
1da177e4 LT |
268 | |
269 | de = (struct sysv_dir_entry *) base; | |
270 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); | |
271 | strcpy(de->name,"."); | |
272 | de++; | |
273 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), dir->i_ino); | |
274 | strcpy(de->name,".."); | |
275 | ||
26a6441a | 276 | kunmap(page); |
4309093e CH |
277 | dir_commit_chunk(page, 0, 2 * SYSV_DIRSIZE); |
278 | err = sysv_handle_dirsync(inode); | |
1da177e4 | 279 | fail: |
09cbfeaf | 280 | put_page(page); |
1da177e4 LT |
281 | return err; |
282 | } | |
283 | ||
284 | /* | |
285 | * routine to check that the specified directory is empty (for rmdir) | |
286 | */ | |
287 | int sysv_empty_dir(struct inode * inode) | |
288 | { | |
289 | struct super_block *sb = inode->i_sb; | |
290 | struct page *page = NULL; | |
291 | unsigned long i, npages = dir_pages(inode); | |
292 | ||
293 | for (i = 0; i < npages; i++) { | |
294 | char *kaddr; | |
295 | struct sysv_dir_entry * de; | |
1da177e4 | 296 | |
8dd6c7b2 FDF |
297 | kaddr = dir_get_page(inode, i, &page); |
298 | if (IS_ERR(kaddr)) | |
1da177e4 LT |
299 | continue; |
300 | ||
1da177e4 | 301 | de = (struct sysv_dir_entry *)kaddr; |
09cbfeaf | 302 | kaddr += PAGE_SIZE-SYSV_DIRSIZE; |
1da177e4 LT |
303 | |
304 | for ( ;(char *)de <= kaddr; de++) { | |
305 | if (!de->inode) | |
306 | continue; | |
307 | /* check for . and .. */ | |
308 | if (de->name[0] != '.') | |
309 | goto not_empty; | |
310 | if (!de->name[1]) { | |
311 | if (de->inode == cpu_to_fs16(SYSV_SB(sb), | |
312 | inode->i_ino)) | |
313 | continue; | |
314 | goto not_empty; | |
315 | } | |
316 | if (de->name[1] != '.' || de->name[2]) | |
317 | goto not_empty; | |
318 | } | |
319 | dir_put_page(page); | |
320 | } | |
321 | return 1; | |
322 | ||
323 | not_empty: | |
324 | dir_put_page(page); | |
325 | return 0; | |
326 | } | |
327 | ||
328 | /* Releases the page */ | |
329 | void sysv_set_link(struct sysv_dir_entry *de, struct page *page, | |
330 | struct inode *inode) | |
331 | { | |
f4e420dc | 332 | struct inode *dir = page->mapping->host; |
4bb1a137 | 333 | loff_t pos = page_offset(page) + offset_in_page(de); |
1da177e4 LT |
334 | int err; |
335 | ||
336 | lock_page(page); | |
f4e420dc | 337 | err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE); |
d6735bfc | 338 | BUG_ON(err); |
1da177e4 | 339 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); |
4309093e | 340 | dir_commit_chunk(page, pos, SYSV_DIRSIZE); |
1da177e4 | 341 | dir_put_page(page); |
02027d42 | 342 | dir->i_mtime = dir->i_ctime = current_time(dir); |
1da177e4 | 343 | mark_inode_dirty(dir); |
4309093e | 344 | sysv_handle_dirsync(inode); |
1da177e4 LT |
345 | } |
346 | ||
8dd6c7b2 | 347 | struct sysv_dir_entry *sysv_dotdot(struct inode *dir, struct page **p) |
1da177e4 | 348 | { |
8dd6c7b2 | 349 | struct sysv_dir_entry *de = dir_get_page(dir, 0, p); |
1da177e4 | 350 | |
8dd6c7b2 FDF |
351 | if (IS_ERR(de)) |
352 | return NULL; | |
353 | /* ".." is the second directory entry */ | |
354 | return de + 1; | |
1da177e4 LT |
355 | } |
356 | ||
357 | ino_t sysv_inode_by_name(struct dentry *dentry) | |
358 | { | |
359 | struct page *page; | |
360 | struct sysv_dir_entry *de = sysv_find_entry (dentry, &page); | |
361 | ino_t res = 0; | |
362 | ||
363 | if (de) { | |
364 | res = fs16_to_cpu(SYSV_SB(dentry->d_sb), de->inode); | |
365 | dir_put_page(page); | |
366 | } | |
367 | return res; | |
368 | } |