Subversion Repositories HelenOS

Rev

Rev 4327 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4327 Rev 4581
Line 52... Line 52...
52 
    uint8_t type;
 52 
    uint8_t type;
53 
    uint32_t len;
 53 
    uint32_t len;
54 
} __attribute__((packed));
 54 
} __attribute__((packed));
55 
 
 55 
 
56 
static bool
 56 
static bool
57 
tmpfs_restore_recursion(int dev, off_t *bufpos, size_t *buflen, off_t *pos,
 57 
tmpfs_restore_recursion(dev_handle_t dev, off_t *bufpos, size_t *buflen,
58 
    tmpfs_dentry_t *parent)
 58 
    off_t *pos, fs_node_t *pfn)
59 
{
 59 
{
60 
    struct rdentry entry;
 60 
    struct rdentry entry;
61 
    libfs_ops_t *ops = &tmpfs_libfs_ops;
 61 
    libfs_ops_t *ops = &tmpfs_libfs_ops;
62 
    int rc;
 62 
    int rc;
63 
   
 63 
   
64 
    do {
 64 
    do {
65 
        char *fname;
 65 
        char *fname;
- 
 
 66 
        fs_node_t *fn;
66 
        tmpfs_dentry_t *node;
 67 
        tmpfs_node_t *nodep;
67 
        uint32_t size;
 68 
        uint32_t size;
68 
       
 69 
       
69 
        if (block_read(dev, bufpos, buflen, pos, &entry, sizeof(entry),
 70 
        if (block_read(dev, bufpos, buflen, pos, &entry, sizeof(entry),
70 
            TMPFS_BLOCK_SIZE) != EOK)
 71 
            TMPFS_BLOCK_SIZE) != EOK)
71 
            return false;
 72 
            return false;
Line 78... Line 79...
78 
        case TMPFS_FILE:
 79 
        case TMPFS_FILE:
79 
            fname = malloc(entry.len + 1);
 80 
            fname = malloc(entry.len + 1);
80 
            if (fname == NULL)
 81 
            if (fname == NULL)
81 
                return false;
 82 
                return false;
82 
           
 83 
           
83 
            node = (tmpfs_dentry_t *) ops->create(dev, L_FILE);
 84 
            fn = ops->create(dev, L_FILE);
84 
            if (node == NULL) {
 85 
            if (fn == NULL) {
85 
                free(fname);
 86 
                free(fname);
86 
                return false;
 87 
                return false;
87 
            }
 88 
            }
88 
           
 89 
           
89 
            if (block_read(dev, bufpos, buflen, pos, fname,
 90 
            if (block_read(dev, bufpos, buflen, pos, fname,
90 
                entry.len, TMPFS_BLOCK_SIZE) != EOK) {
 91 
                entry.len, TMPFS_BLOCK_SIZE) != EOK) {
91 
                ops->destroy((void *) node);
 92 
                ops->destroy(fn);
92 
                free(fname);
 93 
                free(fname);
93 
                return false;
 94 
                return false;
94 
            }
 95 
            }
95 
            fname[entry.len] = 0;
 96 
            fname[entry.len] = 0;
96 
           
 97 
           
97 
            rc = ops->link((void *) parent, (void *) node, fname);
 98 
            rc = ops->link(pfn, fn, fname);
98 
            if (rc != EOK) {
 99 
            if (rc != EOK) {
99 
                ops->destroy((void *) node);
 100 
                ops->destroy(fn);
100 
                free(fname);
 101 
                free(fname);
101 
                return false;
 102 
                return false;
102 
            }
 103 
            }
103 
            free(fname);
 104 
            free(fname);
104 
           
 105 
           
Line 106... Line 107...
106 
                sizeof(size), TMPFS_BLOCK_SIZE) != EOK)
 107 
                sizeof(size), TMPFS_BLOCK_SIZE) != EOK)
107 
                return false;
 108 
                return false;
108 
           
 109 
           
109 
            size = uint32_t_le2host(size);
 110 
            size = uint32_t_le2host(size);
110 
           
 111 
           
- 
 
 112 
            nodep = TMPFS_NODE(fn);
111 
            node->data = malloc(size);
 113 
            nodep->data = malloc(size);
112 
            if (node->data == NULL)
 114 
            if (nodep->data == NULL)
113 
                return false;
 115 
                return false;
114 
           
 116 
           
115 
            node->size = size;
 117 
            nodep->size = size;
116 
            if (block_read(dev, bufpos, buflen, pos, node->data,
 118 
            if (block_read(dev, bufpos, buflen, pos, nodep->data,
117 
                size, TMPFS_BLOCK_SIZE) != EOK)
 119 
                size, TMPFS_BLOCK_SIZE) != EOK)
118 
                return false;
 120 
                return false;
119 
           
 121 
           
120 
            break;
 122 
            break;
121 
        case TMPFS_DIRECTORY:
 123 
        case TMPFS_DIRECTORY:
122 
            fname = malloc(entry.len + 1);
 124 
            fname = malloc(entry.len + 1);
123 
            if (fname == NULL)
 125 
            if (fname == NULL)
124 
                return false;
 126 
                return false;
125 
           
 127 
           
126 
            node = (tmpfs_dentry_t *) ops->create(dev, L_DIRECTORY);
 128 
            fn = ops->create(dev, L_DIRECTORY);
127 
            if (node == NULL) {
 129 
            if (fn == NULL) {
128 
                free(fname);
 130 
                free(fname);
129 
                return false;
 131 
                return false;
130 
            }
 132 
            }
131 
           
 133 
           
132 
            if (block_read(dev, bufpos, buflen, pos, fname,
 134 
            if (block_read(dev, bufpos, buflen, pos, fname,
133 
                entry.len, TMPFS_BLOCK_SIZE) != EOK) {
 135 
                entry.len, TMPFS_BLOCK_SIZE) != EOK) {
134 
                ops->destroy((void *) node);
 136 
                ops->destroy(fn);
135 
                free(fname);
 137 
                free(fname);
136 
                return false;
 138 
                return false;
137 
            }
 139 
            }
138 
            fname[entry.len] = 0;
 140 
            fname[entry.len] = 0;
139 
 
 141 
 
140 
            rc = ops->link((void *) parent, (void *) node, fname);
 142 
            rc = ops->link(pfn, fn, fname);
141 
            if (rc != EOK) {
 143 
            if (rc != EOK) {
142 
                ops->destroy((void *) node);
 144 
                ops->destroy(fn);
143 
                free(fname);
 145 
                free(fname);
144 
                return false;
 146 
                return false;
145 
            }
 147 
            }
146 
            free(fname);
 148 
            free(fname);
147 
           
 149 
           
148 
            if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos,
 150 
            if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos,
149 
                node))
 151 
                fn))
150 
                return false;
 152 
                return false;
151 
           
 153 
           
152 
            break;
 154 
            break;
153 
        default:
 155 
        default:
154 
            return false;
 156 
            return false;