Branch data Line data Source code
1 : : /*
2 : : * JFFS2 -- Journalling Flash File System, Version 2.
3 : : *
4 : : * Copyright © 2001-2007 Red Hat, Inc.
5 : : * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
6 : : *
7 : : * Created by David Woodhouse <dwmw2@infradead.org>
8 : : *
9 : : * For licensing information, see the file 'LICENCE' in this directory.
10 : : *
11 : : */
12 : :
13 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 : :
15 : : #include <linux/kernel.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/fs.h>
18 : : #include <linux/crc32.h>
19 : : #include <linux/jffs2.h>
20 : : #include "jffs2_fs_i.h"
21 : : #include "jffs2_fs_sb.h"
22 : : #include <linux/time.h>
23 : : #include "nodelist.h"
24 : :
25 : : static int jffs2_readdir (struct file *, struct dir_context *);
26 : :
27 : : static int jffs2_create (struct inode *,struct dentry *,umode_t,
28 : : bool);
29 : : static struct dentry *jffs2_lookup (struct inode *,struct dentry *,
30 : : unsigned int);
31 : : static int jffs2_link (struct dentry *,struct inode *,struct dentry *);
32 : : static int jffs2_unlink (struct inode *,struct dentry *);
33 : : static int jffs2_symlink (struct inode *,struct dentry *,const char *);
34 : : static int jffs2_mkdir (struct inode *,struct dentry *,umode_t);
35 : : static int jffs2_rmdir (struct inode *,struct dentry *);
36 : : static int jffs2_mknod (struct inode *,struct dentry *,umode_t,dev_t);
37 : : static int jffs2_rename (struct inode *, struct dentry *,
38 : : struct inode *, struct dentry *);
39 : :
40 : : const struct file_operations jffs2_dir_operations =
41 : : {
42 : : .read = generic_read_dir,
43 : : .iterate = jffs2_readdir,
44 : : .unlocked_ioctl=jffs2_ioctl,
45 : : .fsync = jffs2_fsync,
46 : : .llseek = generic_file_llseek,
47 : : };
48 : :
49 : :
50 : : const struct inode_operations jffs2_dir_inode_operations =
51 : : {
52 : : .create = jffs2_create,
53 : : .lookup = jffs2_lookup,
54 : : .link = jffs2_link,
55 : : .unlink = jffs2_unlink,
56 : : .symlink = jffs2_symlink,
57 : : .mkdir = jffs2_mkdir,
58 : : .rmdir = jffs2_rmdir,
59 : : .mknod = jffs2_mknod,
60 : : .rename = jffs2_rename,
61 : : .get_acl = jffs2_get_acl,
62 : : .setattr = jffs2_setattr,
63 : : .setxattr = jffs2_setxattr,
64 : : .getxattr = jffs2_getxattr,
65 : : .listxattr = jffs2_listxattr,
66 : : .removexattr = jffs2_removexattr
67 : : };
68 : :
69 : : /***********************************************************************/
70 : :
71 : :
72 : : /* We keep the dirent list sorted in increasing order of name hash,
73 : : and we use the same hash function as the dentries. Makes this
74 : : nice and simple
75 : : */
76 : 0 : static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
77 : : unsigned int flags)
78 : : {
79 : : struct jffs2_inode_info *dir_f;
80 : : struct jffs2_full_dirent *fd = NULL, *fd_list;
81 : : uint32_t ino = 0;
82 : : struct inode *inode = NULL;
83 : :
84 : : jffs2_dbg(1, "jffs2_lookup()\n");
85 : :
86 [ # # ]: 0 : if (target->d_name.len > JFFS2_MAX_NAME_LEN)
87 : : return ERR_PTR(-ENAMETOOLONG);
88 : :
89 : : dir_f = JFFS2_INODE_INFO(dir_i);
90 : :
91 : 0 : mutex_lock(&dir_f->sem);
92 : :
93 : : /* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */
94 [ # # ][ # # ]: 0 : for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= target->d_name.hash; fd_list = fd_list->next) {
95 [ # # ][ # # ]: 0 : if (fd_list->nhash == target->d_name.hash &&
96 [ # # ][ # # ]: 0 : (!fd || fd_list->version > fd->version) &&
97 [ # # ]: 0 : strlen(fd_list->name) == target->d_name.len &&
98 : 0 : !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) {
99 : : fd = fd_list;
100 : : }
101 : : }
102 [ # # ]: 0 : if (fd)
103 : 0 : ino = fd->ino;
104 : 0 : mutex_unlock(&dir_f->sem);
105 [ # # ]: 0 : if (ino) {
106 : 0 : inode = jffs2_iget(dir_i->i_sb, ino);
107 [ # # ]: 0 : if (IS_ERR(inode))
108 : 0 : pr_warn("iget() failed for ino #%u\n", ino);
109 : : }
110 : :
111 : 0 : return d_splice_alias(inode, target);
112 : : }
113 : :
114 : : /***********************************************************************/
115 : :
116 : :
117 : 0 : static int jffs2_readdir(struct file *file, struct dir_context *ctx)
118 : : {
119 : : struct inode *inode = file_inode(file);
120 : : struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
121 : : struct jffs2_full_dirent *fd;
122 : : unsigned long curofs = 1;
123 : :
124 : : jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino);
125 : :
126 [ # # ]: 0 : if (!dir_emit_dots(file, ctx))
127 : : return 0;
128 : :
129 : 0 : mutex_lock(&f->sem);
130 [ # # ]: 0 : for (fd = f->dents; fd; fd = fd->next) {
131 : 0 : curofs++;
132 : : /* First loop: curofs = 2; pos = 2 */
133 [ # # ]: 0 : if (curofs < ctx->pos) {
134 : : jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n",
135 : : fd->name, fd->ino, fd->type, curofs, (unsigned long)ctx->pos);
136 : 0 : continue;
137 : : }
138 [ # # ]: 0 : if (!fd->ino) {
139 : : jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n",
140 : : fd->name);
141 : 0 : ctx->pos++;
142 : 0 : continue;
143 : : }
144 : : jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n",
145 : : (unsigned long)ctx->pos, fd->name, fd->ino, fd->type);
146 [ # # ]: 0 : if (!dir_emit(ctx, fd->name, strlen(fd->name), fd->ino, fd->type))
147 : : break;
148 : 0 : ctx->pos++;
149 : : }
150 : 0 : mutex_unlock(&f->sem);
151 : 0 : return 0;
152 : : }
153 : :
154 : : /***********************************************************************/
155 : :
156 : :
157 : 0 : static int jffs2_create(struct inode *dir_i, struct dentry *dentry,
158 : : umode_t mode, bool excl)
159 : : {
160 : : struct jffs2_raw_inode *ri;
161 : : struct jffs2_inode_info *f, *dir_f;
162 : : struct jffs2_sb_info *c;
163 : : struct inode *inode;
164 : : int ret;
165 : :
166 : 0 : ri = jffs2_alloc_raw_inode();
167 [ # # ]: 0 : if (!ri)
168 : : return -ENOMEM;
169 : :
170 : 0 : c = JFFS2_SB_INFO(dir_i->i_sb);
171 : :
172 : : jffs2_dbg(1, "%s()\n", __func__);
173 : :
174 : 0 : inode = jffs2_new_inode(dir_i, mode, ri);
175 : :
176 [ # # ]: 0 : if (IS_ERR(inode)) {
177 : : jffs2_dbg(1, "jffs2_new_inode() failed\n");
178 : 0 : jffs2_free_raw_inode(ri);
179 : 0 : return PTR_ERR(inode);
180 : : }
181 : :
182 : 0 : inode->i_op = &jffs2_file_inode_operations;
183 : 0 : inode->i_fop = &jffs2_file_operations;
184 : 0 : inode->i_mapping->a_ops = &jffs2_file_address_operations;
185 : 0 : inode->i_mapping->nrpages = 0;
186 : :
187 : 0 : f = JFFS2_INODE_INFO(inode);
188 : 0 : dir_f = JFFS2_INODE_INFO(dir_i);
189 : :
190 : : /* jffs2_do_create() will want to lock it, _after_ reserving
191 : : space and taking c-alloc_sem. If we keep it locked here,
192 : : lockdep gets unhappy (although it's a false positive;
193 : : nothing else will be looking at this inode yet so there's
194 : : no chance of AB-BA deadlock involving its f->sem). */
195 : 0 : mutex_unlock(&f->sem);
196 : :
197 : 0 : ret = jffs2_do_create(c, dir_f, f, ri, &dentry->d_name);
198 [ # # ]: 0 : if (ret)
199 : : goto fail;
200 : :
201 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime));
202 : :
203 : 0 : jffs2_free_raw_inode(ri);
204 : :
205 : : jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
206 : : __func__, inode->i_ino, inode->i_mode, inode->i_nlink,
207 : : f->inocache->pino_nlink, inode->i_mapping->nrpages);
208 : :
209 : 0 : unlock_new_inode(inode);
210 : 0 : d_instantiate(dentry, inode);
211 : 0 : return 0;
212 : :
213 : : fail:
214 : 0 : iget_failed(inode);
215 : 0 : jffs2_free_raw_inode(ri);
216 : 0 : return ret;
217 : : }
218 : :
219 : : /***********************************************************************/
220 : :
221 : :
222 : 0 : static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
223 : : {
224 : 0 : struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
225 : 0 : struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
226 : 0 : struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(dentry->d_inode);
227 : : int ret;
228 : 0 : uint32_t now = get_seconds();
229 : :
230 : 0 : ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
231 : 0 : dentry->d_name.len, dead_f, now);
232 [ # # ]: 0 : if (dead_f->inocache)
233 : 0 : set_nlink(dentry->d_inode, dead_f->inocache->pino_nlink);
234 [ # # ]: 0 : if (!ret)
235 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
236 : 0 : return ret;
237 : : }
238 : : /***********************************************************************/
239 : :
240 : :
241 : 0 : static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry)
242 : : {
243 : 0 : struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_inode->i_sb);
244 : : struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
245 : 0 : struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
246 : : int ret;
247 : : uint8_t type;
248 : : uint32_t now;
249 : :
250 : : /* Don't let people make hard links to bad inodes. */
251 [ # # ]: 0 : if (!f->inocache)
252 : : return -EIO;
253 : :
254 [ # # ]: 0 : if (S_ISDIR(old_dentry->d_inode->i_mode))
255 : : return -EPERM;
256 : :
257 : : /* XXX: This is ugly */
258 : 0 : type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
259 [ # # ]: 0 : if (!type) type = DT_REG;
260 : :
261 : 0 : now = get_seconds();
262 : 0 : ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now);
263 : :
264 [ # # ]: 0 : if (!ret) {
265 : 0 : mutex_lock(&f->sem);
266 : 0 : set_nlink(old_dentry->d_inode, ++f->inocache->pino_nlink);
267 : 0 : mutex_unlock(&f->sem);
268 : 0 : d_instantiate(dentry, old_dentry->d_inode);
269 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
270 : 0 : ihold(old_dentry->d_inode);
271 : : }
272 : 0 : return ret;
273 : : }
274 : :
275 : : /***********************************************************************/
276 : :
277 : 0 : static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char *target)
278 : : {
279 : : struct jffs2_inode_info *f, *dir_f;
280 : : struct jffs2_sb_info *c;
281 : : struct inode *inode;
282 : : struct jffs2_raw_inode *ri;
283 : : struct jffs2_raw_dirent *rd;
284 : : struct jffs2_full_dnode *fn;
285 : : struct jffs2_full_dirent *fd;
286 : : int namelen;
287 : : uint32_t alloclen;
288 : 0 : int ret, targetlen = strlen(target);
289 : :
290 : : /* FIXME: If you care. We'd need to use frags for the target
291 : : if it grows much more than this */
292 [ # # ]: 0 : if (targetlen > 254)
293 : : return -ENAMETOOLONG;
294 : :
295 : 0 : ri = jffs2_alloc_raw_inode();
296 : :
297 [ # # ]: 0 : if (!ri)
298 : : return -ENOMEM;
299 : :
300 : 0 : c = JFFS2_SB_INFO(dir_i->i_sb);
301 : :
302 : : /* Try to reserve enough space for both node and dirent.
303 : : * Just the node will do for now, though
304 : : */
305 : 0 : namelen = dentry->d_name.len;
306 : 0 : ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen,
307 : : ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
308 : :
309 [ # # ]: 0 : if (ret) {
310 : 0 : jffs2_free_raw_inode(ri);
311 : 0 : return ret;
312 : : }
313 : :
314 : 0 : inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri);
315 : :
316 [ # # ]: 0 : if (IS_ERR(inode)) {
317 : 0 : jffs2_free_raw_inode(ri);
318 : 0 : jffs2_complete_reservation(c);
319 : 0 : return PTR_ERR(inode);
320 : : }
321 : :
322 : 0 : inode->i_op = &jffs2_symlink_inode_operations;
323 : :
324 : 0 : f = JFFS2_INODE_INFO(inode);
325 : :
326 : 0 : inode->i_size = targetlen;
327 : 0 : ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
328 : 0 : ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
329 : 0 : ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
330 : :
331 : 0 : ri->compr = JFFS2_COMPR_NONE;
332 : 0 : ri->data_crc = cpu_to_je32(crc32(0, target, targetlen));
333 : 0 : ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
334 : :
335 : 0 : fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL);
336 : :
337 : 0 : jffs2_free_raw_inode(ri);
338 : :
339 [ # # ]: 0 : if (IS_ERR(fn)) {
340 : : /* Eeek. Wave bye bye */
341 : 0 : mutex_unlock(&f->sem);
342 : 0 : jffs2_complete_reservation(c);
343 : : ret = PTR_ERR(fn);
344 : 0 : goto fail;
345 : : }
346 : :
347 : : /* We use f->target field to store the target path. */
348 : 0 : f->target = kmemdup(target, targetlen + 1, GFP_KERNEL);
349 [ # # ]: 0 : if (!f->target) {
350 : 0 : pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1);
351 : 0 : mutex_unlock(&f->sem);
352 : 0 : jffs2_complete_reservation(c);
353 : : ret = -ENOMEM;
354 : 0 : goto fail;
355 : : }
356 : :
357 : : jffs2_dbg(1, "%s(): symlink's target '%s' cached\n",
358 : : __func__, (char *)f->target);
359 : :
360 : : /* No data here. Only a metadata node, which will be
361 : : obsoleted by the first data write
362 : : */
363 : 0 : f->metadata = fn;
364 : 0 : mutex_unlock(&f->sem);
365 : :
366 : 0 : jffs2_complete_reservation(c);
367 : :
368 : 0 : ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
369 [ # # ]: 0 : if (ret)
370 : : goto fail;
371 : :
372 : 0 : ret = jffs2_init_acl_post(inode);
373 [ # # ]: 0 : if (ret)
374 : : goto fail;
375 : :
376 : 0 : ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
377 : : ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
378 [ # # ]: 0 : if (ret)
379 : : goto fail;
380 : :
381 : 0 : rd = jffs2_alloc_raw_dirent();
382 [ # # ]: 0 : if (!rd) {
383 : : /* Argh. Now we treat it like a normal delete */
384 : 0 : jffs2_complete_reservation(c);
385 : : ret = -ENOMEM;
386 : 0 : goto fail;
387 : : }
388 : :
389 : 0 : dir_f = JFFS2_INODE_INFO(dir_i);
390 : 0 : mutex_lock(&dir_f->sem);
391 : :
392 : 0 : rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
393 : 0 : rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
394 : 0 : rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
395 : 0 : rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
396 : :
397 : 0 : rd->pino = cpu_to_je32(dir_i->i_ino);
398 : 0 : rd->version = cpu_to_je32(++dir_f->highest_version);
399 : 0 : rd->ino = cpu_to_je32(inode->i_ino);
400 : 0 : rd->mctime = cpu_to_je32(get_seconds());
401 : 0 : rd->nsize = namelen;
402 : 0 : rd->type = DT_LNK;
403 : 0 : rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
404 : 0 : rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
405 : :
406 : 0 : fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
407 : :
408 [ # # ]: 0 : if (IS_ERR(fd)) {
409 : : /* dirent failed to write. Delete the inode normally
410 : : as if it were the final unlink() */
411 : 0 : jffs2_complete_reservation(c);
412 : 0 : jffs2_free_raw_dirent(rd);
413 : 0 : mutex_unlock(&dir_f->sem);
414 : : ret = PTR_ERR(fd);
415 : 0 : goto fail;
416 : : }
417 : :
418 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
419 : :
420 : 0 : jffs2_free_raw_dirent(rd);
421 : :
422 : : /* Link the fd into the inode's list, obsoleting an old
423 : : one if necessary. */
424 : 0 : jffs2_add_fd_to_list(c, fd, &dir_f->dents);
425 : :
426 : 0 : mutex_unlock(&dir_f->sem);
427 : 0 : jffs2_complete_reservation(c);
428 : :
429 : 0 : unlock_new_inode(inode);
430 : 0 : d_instantiate(dentry, inode);
431 : 0 : return 0;
432 : :
433 : : fail:
434 : 0 : iget_failed(inode);
435 : 0 : return ret;
436 : : }
437 : :
438 : :
439 : 0 : static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, umode_t mode)
440 : : {
441 : : struct jffs2_inode_info *f, *dir_f;
442 : : struct jffs2_sb_info *c;
443 : : struct inode *inode;
444 : : struct jffs2_raw_inode *ri;
445 : : struct jffs2_raw_dirent *rd;
446 : : struct jffs2_full_dnode *fn;
447 : : struct jffs2_full_dirent *fd;
448 : : int namelen;
449 : : uint32_t alloclen;
450 : : int ret;
451 : :
452 : 0 : mode |= S_IFDIR;
453 : :
454 : 0 : ri = jffs2_alloc_raw_inode();
455 [ # # ]: 0 : if (!ri)
456 : : return -ENOMEM;
457 : :
458 : 0 : c = JFFS2_SB_INFO(dir_i->i_sb);
459 : :
460 : : /* Try to reserve enough space for both node and dirent.
461 : : * Just the node will do for now, though
462 : : */
463 : 0 : namelen = dentry->d_name.len;
464 : 0 : ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
465 : : JFFS2_SUMMARY_INODE_SIZE);
466 : :
467 [ # # ]: 0 : if (ret) {
468 : 0 : jffs2_free_raw_inode(ri);
469 : 0 : return ret;
470 : : }
471 : :
472 : 0 : inode = jffs2_new_inode(dir_i, mode, ri);
473 : :
474 [ # # ]: 0 : if (IS_ERR(inode)) {
475 : 0 : jffs2_free_raw_inode(ri);
476 : 0 : jffs2_complete_reservation(c);
477 : 0 : return PTR_ERR(inode);
478 : : }
479 : :
480 : 0 : inode->i_op = &jffs2_dir_inode_operations;
481 : 0 : inode->i_fop = &jffs2_dir_operations;
482 : :
483 : 0 : f = JFFS2_INODE_INFO(inode);
484 : :
485 : : /* Directories get nlink 2 at start */
486 : 0 : set_nlink(inode, 2);
487 : : /* but ic->pino_nlink is the parent ino# */
488 : 0 : f->inocache->pino_nlink = dir_i->i_ino;
489 : :
490 : 0 : ri->data_crc = cpu_to_je32(0);
491 : 0 : ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
492 : :
493 : 0 : fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
494 : :
495 : 0 : jffs2_free_raw_inode(ri);
496 : :
497 [ # # ]: 0 : if (IS_ERR(fn)) {
498 : : /* Eeek. Wave bye bye */
499 : 0 : mutex_unlock(&f->sem);
500 : 0 : jffs2_complete_reservation(c);
501 : : ret = PTR_ERR(fn);
502 : 0 : goto fail;
503 : : }
504 : : /* No data here. Only a metadata node, which will be
505 : : obsoleted by the first data write
506 : : */
507 : 0 : f->metadata = fn;
508 : 0 : mutex_unlock(&f->sem);
509 : :
510 : 0 : jffs2_complete_reservation(c);
511 : :
512 : 0 : ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
513 [ # # ]: 0 : if (ret)
514 : : goto fail;
515 : :
516 : 0 : ret = jffs2_init_acl_post(inode);
517 [ # # ]: 0 : if (ret)
518 : : goto fail;
519 : :
520 : 0 : ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
521 : : ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
522 [ # # ]: 0 : if (ret)
523 : : goto fail;
524 : :
525 : 0 : rd = jffs2_alloc_raw_dirent();
526 [ # # ]: 0 : if (!rd) {
527 : : /* Argh. Now we treat it like a normal delete */
528 : 0 : jffs2_complete_reservation(c);
529 : : ret = -ENOMEM;
530 : 0 : goto fail;
531 : : }
532 : :
533 : 0 : dir_f = JFFS2_INODE_INFO(dir_i);
534 : 0 : mutex_lock(&dir_f->sem);
535 : :
536 : 0 : rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
537 : 0 : rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
538 : 0 : rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
539 : 0 : rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
540 : :
541 : 0 : rd->pino = cpu_to_je32(dir_i->i_ino);
542 : 0 : rd->version = cpu_to_je32(++dir_f->highest_version);
543 : 0 : rd->ino = cpu_to_je32(inode->i_ino);
544 : 0 : rd->mctime = cpu_to_je32(get_seconds());
545 : 0 : rd->nsize = namelen;
546 : 0 : rd->type = DT_DIR;
547 : 0 : rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
548 : 0 : rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
549 : :
550 : 0 : fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
551 : :
552 [ # # ]: 0 : if (IS_ERR(fd)) {
553 : : /* dirent failed to write. Delete the inode normally
554 : : as if it were the final unlink() */
555 : 0 : jffs2_complete_reservation(c);
556 : 0 : jffs2_free_raw_dirent(rd);
557 : 0 : mutex_unlock(&dir_f->sem);
558 : : ret = PTR_ERR(fd);
559 : 0 : goto fail;
560 : : }
561 : :
562 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
563 : 0 : inc_nlink(dir_i);
564 : :
565 : 0 : jffs2_free_raw_dirent(rd);
566 : :
567 : : /* Link the fd into the inode's list, obsoleting an old
568 : : one if necessary. */
569 : 0 : jffs2_add_fd_to_list(c, fd, &dir_f->dents);
570 : :
571 : 0 : mutex_unlock(&dir_f->sem);
572 : 0 : jffs2_complete_reservation(c);
573 : :
574 : 0 : unlock_new_inode(inode);
575 : 0 : d_instantiate(dentry, inode);
576 : 0 : return 0;
577 : :
578 : : fail:
579 : 0 : iget_failed(inode);
580 : 0 : return ret;
581 : : }
582 : :
583 : 0 : static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
584 : : {
585 : 0 : struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
586 : 0 : struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
587 : 0 : struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode);
588 : : struct jffs2_full_dirent *fd;
589 : : int ret;
590 : 0 : uint32_t now = get_seconds();
591 : :
592 [ # # ]: 0 : for (fd = f->dents ; fd; fd = fd->next) {
593 [ # # ]: 0 : if (fd->ino)
594 : : return -ENOTEMPTY;
595 : : }
596 : :
597 : 0 : ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
598 : 0 : dentry->d_name.len, f, now);
599 [ # # ]: 0 : if (!ret) {
600 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
601 : 0 : clear_nlink(dentry->d_inode);
602 : 0 : drop_nlink(dir_i);
603 : : }
604 : 0 : return ret;
605 : : }
606 : :
607 : 0 : static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode, dev_t rdev)
608 : : {
609 : : struct jffs2_inode_info *f, *dir_f;
610 : : struct jffs2_sb_info *c;
611 : : struct inode *inode;
612 : : struct jffs2_raw_inode *ri;
613 : : struct jffs2_raw_dirent *rd;
614 : : struct jffs2_full_dnode *fn;
615 : : struct jffs2_full_dirent *fd;
616 : : int namelen;
617 : : union jffs2_device_node dev;
618 : : int devlen = 0;
619 : : uint32_t alloclen;
620 : : int ret;
621 : :
622 : : if (!new_valid_dev(rdev))
623 : : return -EINVAL;
624 : :
625 : 0 : ri = jffs2_alloc_raw_inode();
626 [ # # ]: 0 : if (!ri)
627 : : return -ENOMEM;
628 : :
629 : 0 : c = JFFS2_SB_INFO(dir_i->i_sb);
630 : :
631 [ # # ]: 0 : if (S_ISBLK(mode) || S_ISCHR(mode))
632 : : devlen = jffs2_encode_dev(&dev, rdev);
633 : :
634 : : /* Try to reserve enough space for both node and dirent.
635 : : * Just the node will do for now, though
636 : : */
637 : 0 : namelen = dentry->d_name.len;
638 : 0 : ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen,
639 : : ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
640 : :
641 [ # # ]: 0 : if (ret) {
642 : 0 : jffs2_free_raw_inode(ri);
643 : 0 : return ret;
644 : : }
645 : :
646 : 0 : inode = jffs2_new_inode(dir_i, mode, ri);
647 : :
648 [ # # ]: 0 : if (IS_ERR(inode)) {
649 : 0 : jffs2_free_raw_inode(ri);
650 : 0 : jffs2_complete_reservation(c);
651 : 0 : return PTR_ERR(inode);
652 : : }
653 : 0 : inode->i_op = &jffs2_file_inode_operations;
654 : 0 : init_special_inode(inode, inode->i_mode, rdev);
655 : :
656 : 0 : f = JFFS2_INODE_INFO(inode);
657 : :
658 : 0 : ri->dsize = ri->csize = cpu_to_je32(devlen);
659 : 0 : ri->totlen = cpu_to_je32(sizeof(*ri) + devlen);
660 : 0 : ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
661 : :
662 : 0 : ri->compr = JFFS2_COMPR_NONE;
663 : 0 : ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen));
664 : 0 : ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
665 : :
666 : 0 : fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL);
667 : :
668 : 0 : jffs2_free_raw_inode(ri);
669 : :
670 [ # # ]: 0 : if (IS_ERR(fn)) {
671 : : /* Eeek. Wave bye bye */
672 : 0 : mutex_unlock(&f->sem);
673 : 0 : jffs2_complete_reservation(c);
674 : : ret = PTR_ERR(fn);
675 : 0 : goto fail;
676 : : }
677 : : /* No data here. Only a metadata node, which will be
678 : : obsoleted by the first data write
679 : : */
680 : 0 : f->metadata = fn;
681 : 0 : mutex_unlock(&f->sem);
682 : :
683 : 0 : jffs2_complete_reservation(c);
684 : :
685 : 0 : ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
686 [ # # ]: 0 : if (ret)
687 : : goto fail;
688 : :
689 : 0 : ret = jffs2_init_acl_post(inode);
690 [ # # ]: 0 : if (ret)
691 : : goto fail;
692 : :
693 : 0 : ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
694 : : ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
695 [ # # ]: 0 : if (ret)
696 : : goto fail;
697 : :
698 : 0 : rd = jffs2_alloc_raw_dirent();
699 [ # # ]: 0 : if (!rd) {
700 : : /* Argh. Now we treat it like a normal delete */
701 : 0 : jffs2_complete_reservation(c);
702 : : ret = -ENOMEM;
703 : 0 : goto fail;
704 : : }
705 : :
706 : 0 : dir_f = JFFS2_INODE_INFO(dir_i);
707 : 0 : mutex_lock(&dir_f->sem);
708 : :
709 : 0 : rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
710 : 0 : rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
711 : 0 : rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
712 : 0 : rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
713 : :
714 : 0 : rd->pino = cpu_to_je32(dir_i->i_ino);
715 : 0 : rd->version = cpu_to_je32(++dir_f->highest_version);
716 : 0 : rd->ino = cpu_to_je32(inode->i_ino);
717 : 0 : rd->mctime = cpu_to_je32(get_seconds());
718 : 0 : rd->nsize = namelen;
719 : :
720 : : /* XXX: This is ugly. */
721 : 0 : rd->type = (mode & S_IFMT) >> 12;
722 : :
723 : 0 : rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
724 : 0 : rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
725 : :
726 : 0 : fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
727 : :
728 [ # # ]: 0 : if (IS_ERR(fd)) {
729 : : /* dirent failed to write. Delete the inode normally
730 : : as if it were the final unlink() */
731 : 0 : jffs2_complete_reservation(c);
732 : 0 : jffs2_free_raw_dirent(rd);
733 : 0 : mutex_unlock(&dir_f->sem);
734 : : ret = PTR_ERR(fd);
735 : 0 : goto fail;
736 : : }
737 : :
738 : 0 : dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
739 : :
740 : 0 : jffs2_free_raw_dirent(rd);
741 : :
742 : : /* Link the fd into the inode's list, obsoleting an old
743 : : one if necessary. */
744 : 0 : jffs2_add_fd_to_list(c, fd, &dir_f->dents);
745 : :
746 : 0 : mutex_unlock(&dir_f->sem);
747 : 0 : jffs2_complete_reservation(c);
748 : :
749 : 0 : unlock_new_inode(inode);
750 : 0 : d_instantiate(dentry, inode);
751 : 0 : return 0;
752 : :
753 : : fail:
754 : 0 : iget_failed(inode);
755 : 0 : return ret;
756 : : }
757 : :
758 : 0 : static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
759 : : struct inode *new_dir_i, struct dentry *new_dentry)
760 : : {
761 : : int ret;
762 : 0 : struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
763 : : struct jffs2_inode_info *victim_f = NULL;
764 : : uint8_t type;
765 : : uint32_t now;
766 : :
767 : : /* The VFS will check for us and prevent trying to rename a
768 : : * file over a directory and vice versa, but if it's a directory,
769 : : * the VFS can't check whether the victim is empty. The filesystem
770 : : * needs to do that for itself.
771 : : */
772 [ # # ]: 0 : if (new_dentry->d_inode) {
773 : 0 : victim_f = JFFS2_INODE_INFO(new_dentry->d_inode);
774 [ # # ]: 0 : if (S_ISDIR(new_dentry->d_inode->i_mode)) {
775 : : struct jffs2_full_dirent *fd;
776 : :
777 : 0 : mutex_lock(&victim_f->sem);
778 [ # # ]: 0 : for (fd = victim_f->dents; fd; fd = fd->next) {
779 [ # # ]: 0 : if (fd->ino) {
780 : 0 : mutex_unlock(&victim_f->sem);
781 : 0 : return -ENOTEMPTY;
782 : : }
783 : : }
784 : 0 : mutex_unlock(&victim_f->sem);
785 : : }
786 : : }
787 : :
788 : : /* XXX: We probably ought to alloc enough space for
789 : : both nodes at the same time. Writing the new link,
790 : : then getting -ENOSPC, is quite bad :)
791 : : */
792 : :
793 : : /* Make a hard link */
794 : :
795 : : /* XXX: This is ugly */
796 : 0 : type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
797 [ # # ]: 0 : if (!type) type = DT_REG;
798 : :
799 : 0 : now = get_seconds();
800 : 0 : ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
801 : 0 : old_dentry->d_inode->i_ino, type,
802 : 0 : new_dentry->d_name.name, new_dentry->d_name.len, now);
803 : :
804 [ # # ]: 0 : if (ret)
805 : : return ret;
806 : :
807 [ # # ]: 0 : if (victim_f) {
808 : : /* There was a victim. Kill it off nicely */
809 [ # # ]: 0 : if (S_ISDIR(new_dentry->d_inode->i_mode))
810 : 0 : clear_nlink(new_dentry->d_inode);
811 : : else
812 : 0 : drop_nlink(new_dentry->d_inode);
813 : : /* Don't oops if the victim was a dirent pointing to an
814 : : inode which didn't exist. */
815 [ # # ]: 0 : if (victim_f->inocache) {
816 : 0 : mutex_lock(&victim_f->sem);
817 [ # # ]: 0 : if (S_ISDIR(new_dentry->d_inode->i_mode))
818 : 0 : victim_f->inocache->pino_nlink = 0;
819 : : else
820 : 0 : victim_f->inocache->pino_nlink--;
821 : 0 : mutex_unlock(&victim_f->sem);
822 : : }
823 : : }
824 : :
825 : : /* If it was a directory we moved, and there was no victim,
826 : : increase i_nlink on its new parent */
827 [ # # ][ # # ]: 0 : if (S_ISDIR(old_dentry->d_inode->i_mode) && !victim_f)
828 : 0 : inc_nlink(new_dir_i);
829 : :
830 : : /* Unlink the original */
831 : 0 : ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
832 : 0 : old_dentry->d_name.name, old_dentry->d_name.len, NULL, now);
833 : :
834 : : /* We don't touch inode->i_nlink */
835 : :
836 [ # # ]: 0 : if (ret) {
837 : : /* Oh shit. We really ought to make a single node which can do both atomically */
838 : 0 : struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
839 : 0 : mutex_lock(&f->sem);
840 : 0 : inc_nlink(old_dentry->d_inode);
841 [ # # ][ # # ]: 0 : if (f->inocache && !S_ISDIR(old_dentry->d_inode->i_mode))
842 : 0 : f->inocache->pino_nlink++;
843 : 0 : mutex_unlock(&f->sem);
844 : :
845 : 0 : pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n",
846 : : __func__, ret);
847 : : /* Might as well let the VFS know */
848 : 0 : d_instantiate(new_dentry, old_dentry->d_inode);
849 : 0 : ihold(old_dentry->d_inode);
850 : 0 : new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now);
851 : 0 : return ret;
852 : : }
853 : :
854 [ # # ]: 0 : if (S_ISDIR(old_dentry->d_inode->i_mode))
855 : 0 : drop_nlink(old_dir_i);
856 : :
857 : 0 : new_dir_i->i_mtime = new_dir_i->i_ctime = old_dir_i->i_mtime = old_dir_i->i_ctime = ITIME(now);
858 : :
859 : 0 : return 0;
860 : : }
861 : :
|
