inode.c: fix initialization of i_streams
[wimlib] / src / inode.c
1 /*
2  * inode.c
3  *
4  * Functions that operate on WIM inodes.
5  *
6  * See dentry.c for a description of the relationship between WIM dentries and
7  * WIM inodes.
8  */
9
10 /*
11  * Copyright (C) 2012, 2013, 2014, 2015 Eric Biggers
12  *
13  * This file is free software; you can redistribute it and/or modify it under
14  * the terms of the GNU Lesser General Public License as published by the Free
15  * Software Foundation; either version 3 of the License, or (at your option) any
16  * later version.
17  *
18  * This file is distributed in the hope that it will be useful, but WITHOUT
19  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
21  * details.
22  *
23  * You should have received a copy of the GNU Lesser General Public License
24  * along with this file; if not, see http://www.gnu.org/licenses/.
25  */
26
27 #ifdef HAVE_CONFIG_H
28 #  include "config.h"
29 #endif
30
31 #include <errno.h>
32
33 #include "wimlib/assert.h"
34 #include "wimlib/blob_table.h"
35 #include "wimlib/dentry.h"
36 #include "wimlib/encoding.h"
37 #include "wimlib/error.h"
38 #include "wimlib/inode.h"
39 #include "wimlib/timestamp.h"
40
41 /*
42  * The 'stream_name' field of unnamed streams always points to this array, which
43  * is an empty UTF-16 string.
44  */
45 const utf16lechar NO_STREAM_NAME[1];
46
47 /* Allocate a new inode and associate the specified dentry with it.  */
48 struct wim_inode *
49 new_inode(struct wim_dentry *dentry, bool set_timestamps)
50 {
51         struct wim_inode *inode;
52
53         inode = CALLOC(1, sizeof(struct wim_inode));
54         if (!inode)
55                 return NULL;
56
57         inode->i_security_id = -1;
58         /*inode->i_nlink = 0;*/
59         inode->i_not_rpfixed = 1;
60         INIT_LIST_HEAD(&inode->i_list);
61         INIT_LIST_HEAD(&inode->i_dentry);
62         inode->i_streams = inode->i_embedded_streams;
63         if (set_timestamps) {
64                 u64 now = now_as_wim_timestamp();
65                 inode->i_creation_time = now;
66                 inode->i_last_access_time = now;
67                 inode->i_last_write_time = now;
68         }
69         d_associate(dentry, inode);
70         return inode;
71 }
72
73 static inline void
74 destroy_stream(struct wim_inode_stream *strm)
75 {
76         if (strm->stream_name != NO_STREAM_NAME)
77                 FREE(strm->stream_name);
78 }
79
80 static void
81 free_inode(struct wim_inode *inode)
82 {
83         for (unsigned i = 0; i < inode->i_num_streams; i++)
84                 destroy_stream(&inode->i_streams[i]);
85         if (inode->i_streams != inode->i_embedded_streams)
86                 FREE(inode->i_streams);
87         if (inode->i_extra)
88                 FREE(inode->i_extra);
89         /* HACK: This may instead delete the inode from i_list, but hlist_del()
90          * behaves the same as list_del(). */
91         if (!hlist_unhashed(&inode->i_hlist))
92                 hlist_del(&inode->i_hlist);
93         FREE(inode);
94 }
95
96 static inline void
97 free_inode_if_unneeded(struct wim_inode *inode)
98 {
99         if (inode->i_nlink)
100                 return;
101 #ifdef WITH_FUSE
102         if (inode->i_num_opened_fds)
103                 return;
104 #endif
105         free_inode(inode);
106 }
107
108 /* Associate a dentry with the specified inode.  */
109 void
110 d_associate(struct wim_dentry *dentry, struct wim_inode *inode)
111 {
112         wimlib_assert(!dentry->d_inode);
113
114         list_add_tail(&dentry->d_alias, &inode->i_dentry);
115         dentry->d_inode = inode;
116         inode->i_nlink++;
117 }
118
119 /* Disassociate a dentry from its inode, if any.  Following this, free the inode
120  * if it is no longer in use.  */
121 void
122 d_disassociate(struct wim_dentry *dentry)
123 {
124         struct wim_inode *inode = dentry->d_inode;
125
126         if (unlikely(!inode))
127                 return;
128
129         wimlib_assert(inode->i_nlink > 0);
130
131         list_del(&dentry->d_alias);
132         dentry->d_inode = NULL;
133         inode->i_nlink--;
134
135         free_inode_if_unneeded(inode);
136 }
137
138 #ifdef WITH_FUSE
139 void
140 inode_dec_num_opened_fds(struct wim_inode *inode)
141 {
142         wimlib_assert(inode->i_num_opened_fds > 0);
143
144         if (--inode->i_num_opened_fds == 0) {
145                 /* The last file descriptor to this inode was closed.  */
146                 FREE(inode->i_fds);
147                 inode->i_fds = NULL;
148                 inode->i_num_allocated_fds = 0;
149
150                 free_inode_if_unneeded(inode);
151         }
152 }
153 #endif
154
155 /*
156  * Retrieve a stream of an inode.
157  *
158  * @inode
159  *      The inode from which the stream is desired
160  * @stream_type
161  *      The type of the stream desired
162  * @stream_name
163  *      The name of the stream desired as a null-terminated UTF-16LE string, or
164  *      NO_STREAM_NAME if an unnamed stream is desired
165  *
166  * Returns a pointer to the stream if found, otherwise NULL.
167  */
168 struct wim_inode_stream *
169 inode_get_stream(const struct wim_inode *inode, int stream_type,
170                  const utf16lechar *stream_name)
171 {
172         if (stream_name == NO_STREAM_NAME)  /* Optimization  */
173                 return inode_get_unnamed_stream(inode, stream_type);
174
175         for (unsigned i = 0; i < inode->i_num_streams; i++) {
176                 struct wim_inode_stream *strm = &inode->i_streams[i];
177                 if (strm->stream_type == stream_type &&
178                     !cmp_utf16le_strings_z(strm->stream_name, stream_name,
179                                            default_ignore_case))
180                 {
181                         return strm;
182                 }
183         }
184         return NULL;
185 }
186
187 /*
188  * This is equivalent to inode_get_stream(inode, stream_type, NO_STREAM_NAME),
189  * but this optimizes for the unnamed case by not doing full string comparisons.
190  */
191 struct wim_inode_stream *
192 inode_get_unnamed_stream(const struct wim_inode *inode, int stream_type)
193 {
194         for (unsigned i = 0; i < inode->i_num_streams; i++) {
195                 struct wim_inode_stream *strm = &inode->i_streams[i];
196                 if (strm->stream_type == stream_type &&
197                     strm->stream_name == NO_STREAM_NAME)
198                 {
199                         return strm;
200                 }
201         }
202         return NULL;
203 }
204
205
206 static void
207 inode_set_stream_blob(struct wim_inode *inode, struct wim_inode_stream *strm,
208                       struct blob_descriptor *new_blob)
209 {
210         strm->_stream_blob = new_blob;
211         strm->stream_resolved = 1;
212         if (new_blob)
213                 new_blob->refcnt += inode->i_nlink;
214 }
215
216 static void
217 inode_unset_stream_blob(struct wim_inode *inode, struct wim_inode_stream *strm,
218                         struct blob_table *blob_table)
219 {
220         struct blob_descriptor *old_blob;
221
222         old_blob = stream_blob(strm, blob_table);
223         if (old_blob)
224                 blob_subtract_refcnt(old_blob, blob_table, inode->i_nlink);
225         strm->_stream_blob = NULL;
226         strm->stream_resolved = 1;
227 }
228
229 /*
230  * Replace the blob associated with the specified stream.
231  *
232  * @inode
233  *      The inode containing @strm
234  * @strm
235  *      The stream whose data needs to be replaced
236  * @new_blob
237  *      The new blob descriptor to assign
238  * @blob_table
239  *      Pointer to the blob table in which data blobs are being indexed
240  */
241 void
242 inode_replace_stream_blob(struct wim_inode *inode,
243                           struct wim_inode_stream *strm,
244                           struct blob_descriptor *new_blob,
245                           struct blob_table *blob_table)
246 {
247         inode_unset_stream_blob(inode, strm, blob_table);
248         inode_set_stream_blob(inode, strm, new_blob);
249 }
250
251 /*
252  * Add a new stream to the specified inode.
253  *
254  * @inode
255  *      The inode to which to add the stream
256  * @stream_type
257  *      The type of the stream being added
258  * @stream_name
259  *      The name of the stream being added as a null-terminated UTF-16LE string,
260  *      or NO_STREAM_NAME if the stream is unnamed
261  * @blob
262  *      The blob that the new stream will initially reference, or NULL
263  *
264  * Returns a pointer to the new stream, or NULL with errno set if it could not
265  * be added.
266  */
267 struct wim_inode_stream *
268 inode_add_stream(struct wim_inode *inode, int stream_type,
269                  const utf16lechar *stream_name, struct blob_descriptor *blob)
270 {
271         if (inode->i_num_streams >= 0xFFFF) {
272                 ERROR("Inode has too many streams! Path=\"%"TS"\"",
273                       inode_first_full_path(inode));
274                 errno = EFBIG;
275                 return NULL;
276         }
277
278         struct wim_inode_stream *streams;
279         struct wim_inode_stream *new_strm;
280
281         if (inode->i_streams == inode->i_embedded_streams) {
282                 if (inode->i_num_streams < ARRAY_LEN(inode->i_embedded_streams)) {
283                         streams = inode->i_embedded_streams;
284                 } else {
285                         streams = MALLOC((inode->i_num_streams + 1) *
286                                                 sizeof(inode->i_streams[0]));
287                         if (!streams)
288                                 return NULL;
289                         memcpy(streams, inode->i_streams,
290                                (inode->i_num_streams *
291                                         sizeof(inode->i_streams[0])));
292                         inode->i_streams = streams;
293                 }
294         } else {
295                 streams = REALLOC(inode->i_streams,
296                                   (inode->i_num_streams + 1) *
297                                         sizeof(inode->i_streams[0]));
298                 if (!streams)
299                         return NULL;
300                 inode->i_streams = streams;
301         }
302         new_strm = &streams[inode->i_num_streams];
303
304         memset(new_strm, 0, sizeof(*new_strm));
305
306         new_strm->stream_type = stream_type;
307         if (!*stream_name) {
308                 /* Unnamed stream  */
309                 new_strm->stream_name = (utf16lechar *)NO_STREAM_NAME;
310         } else {
311                 /* Named stream  */
312                 new_strm->stream_name = utf16le_dup(stream_name);
313                 if (!new_strm->stream_name)
314                         return NULL;
315         }
316
317         new_strm->stream_id = inode->i_next_stream_id++;
318
319         inode_set_stream_blob(inode, new_strm, blob);
320
321         inode->i_num_streams++;
322
323         return new_strm;
324 }
325
326 /*
327  * Replace the data of the specified stream.
328  *
329  * @inode
330  *      The inode containing @strm
331  * @strm
332  *      The stream whose data needs to be replaced
333  * @data
334  *      The buffer of data to assign to the stream
335  * @size
336  *      Size of the @data buffer, in bytes
337  * @blob_table
338  *      Pointer to the blob table in which data blobs are being indexed
339  *
340  * Returns true if successful; false with errno set if unsuccessful.
341  */
342 bool
343 inode_replace_stream_data(struct wim_inode *inode,
344                           struct wim_inode_stream *strm,
345                           const void *data, size_t size,
346                           struct blob_table *blob_table)
347 {
348         struct blob_descriptor *new_blob;
349
350         new_blob = new_blob_from_data_buffer(data, size, blob_table);
351         if (!new_blob)
352                 return false;
353
354         inode_replace_stream_blob(inode, strm, new_blob, blob_table);
355         return true;
356 }
357
358 /*
359  * Add a new stream to the specified inode and assign it the specified data.
360  *
361  * @inode
362  *      The inode to which to add the stream
363  * @stream_type
364  *      The type of the stream being added
365  * @stream_name
366  *      The name of the stream being added as a null-terminated UTF-16LE string,
367  *      or NO_STREAM_NAME if the stream is unnamed
368  * @data
369  *      The buffer of data to assign to the new stream
370  * @size
371  *      Size of the @data buffer, in bytes
372  * @blob_table
373  *      Pointer to the blob table in which data blobs are being indexed
374  *
375  * Returns true if successful; false with errno set if unsuccessful.
376  */
377 bool
378 inode_add_stream_with_data(struct wim_inode *inode,
379                            int stream_type, const utf16lechar *stream_name,
380                            const void *data, size_t size,
381                            struct blob_table *blob_table)
382 {
383         struct wim_inode_stream *strm;
384         struct blob_descriptor *blob;
385
386         strm = inode_add_stream(inode, stream_type, stream_name, NULL);
387         if (!strm)
388                 return false;
389
390         blob = new_blob_from_data_buffer(data, size, blob_table);
391         if (!blob) {
392                 inode_remove_stream(inode, strm, blob_table);
393                 return false;
394         }
395
396         inode_set_stream_blob(inode, strm, blob);
397         return true;
398 }
399
400 /*
401  * Remove a stream from the specified inode.
402  *
403  * This handles releasing the references to the blob descriptor, if any.
404  */
405 void
406 inode_remove_stream(struct wim_inode *inode, struct wim_inode_stream *strm,
407                     struct blob_table *blob_table)
408 {
409         unsigned idx = strm - inode->i_streams;
410
411         wimlib_assert(idx < inode->i_num_streams);
412
413         inode_unset_stream_blob(inode, strm, blob_table);
414
415         destroy_stream(strm);
416
417         memmove(strm, strm + 1,
418                 (inode->i_num_streams - idx - 1) * sizeof(inode->i_streams[0]));
419         inode->i_num_streams--;
420 }
421
422 /* Returns true iff the specified inode has at least one named data stream.  */
423 bool
424 inode_has_named_data_stream(const struct wim_inode *inode)
425 {
426         for (unsigned i = 0; i < inode->i_num_streams; i++)
427                 if (stream_is_named_data_stream(&inode->i_streams[i]))
428                         return true;
429         return false;
430 }
431
432 /*
433  * Resolve an inode's streams.
434  *
435  * For each stream, this replaces the SHA-1 message digest of the blob data with
436  * a pointer to the 'struct blob_descriptor' for the blob.  Blob descriptors are
437  * looked up in @table.
438  *
439  * If @force is %false:
440  *      If any of the needed blobs do not exist in @table, return
441  *      WIMLIB_ERR_RESOURCE_NOT_FOUND and leave the inode unmodified.
442  * If @force is %true:
443  *      If any of the needed blobs do not exist in @table, allocate new blob
444  *      descriptors for them and insert them into @table.  This does not, of
445  *      course, cause the data of these blobs to magically exist, but this is
446  *      needed by the code for extraction from a pipe.
447  *
448  * Returns 0 on success; WIMLIB_ERR_NOMEM if out of memory; or
449  * WIMLIB_ERR_RESOURCE_NOT_FOUND if @force is %false and at least one blob
450  * referenced by the inode was missing.
451  */
452 int
453 inode_resolve_streams(struct wim_inode *inode, struct blob_table *table,
454                       bool force)
455 {
456         struct blob_descriptor *blobs[inode->i_num_streams];
457
458         for (unsigned i = 0; i < inode->i_num_streams; i++) {
459
460                 if (inode->i_streams[i].stream_resolved)
461                         continue;
462
463                 const u8 *hash = stream_hash(&inode->i_streams[i]);
464                 struct blob_descriptor *blob = NULL;
465
466                 if (!is_zero_hash(hash)) {
467                         blob = lookup_blob(table, hash);
468                         if (!blob) {
469                                 if (!force)
470                                         return blob_not_found_error(inode, hash);
471                                 blob = new_blob_descriptor();
472                                 if (!blob)
473                                         return WIMLIB_ERR_NOMEM;
474                                 copy_hash(blob->hash, hash);
475                                 blob_table_insert(table, blob);
476                         }
477                 }
478                 blobs[i] = blob;
479         }
480
481         for (unsigned i = 0; i < inode->i_num_streams; i++) {
482                 if (!inode->i_streams[i].stream_resolved) {
483                         inode->i_streams[i]._stream_blob = blobs[i];
484                         inode->i_streams[i].stream_resolved = 1;
485                 }
486         }
487         return 0;
488 }
489
490 /* Undo the effects of inode_resolve_streams().  */
491 void
492 inode_unresolve_streams(struct wim_inode *inode)
493 {
494         for (unsigned i = 0; i < inode->i_num_streams; i++) {
495
496                 if (!inode->i_streams[i].stream_resolved)
497                         continue;
498
499                 copy_hash(inode->i_streams[i]._stream_hash,
500                           stream_hash(&inode->i_streams[i]));
501                 inode->i_streams[i].stream_resolved = 0;
502         }
503 }
504
505 int
506 blob_not_found_error(const struct wim_inode *inode, const u8 *hash)
507 {
508         if (wimlib_print_errors) {
509                 tchar hashstr[SHA1_HASH_SIZE * 2 + 1];
510
511                 sprint_hash(hash, hashstr);
512
513                 ERROR("\"%"TS"\": blob not found\n"
514                       "        SHA-1 message digest of missing blob:\n"
515                       "        %"TS"",
516                       inode_first_full_path(inode), hashstr);
517         }
518         return WIMLIB_ERR_RESOURCE_NOT_FOUND;
519 }
520
521 /*
522  * Return the blob descriptor for the specified stream, or NULL if the blob for
523  * the stream is empty or not available.
524  */
525 struct blob_descriptor *
526 stream_blob(const struct wim_inode_stream *strm, const struct blob_table *table)
527 {
528         if (strm->stream_resolved)
529                 return strm->_stream_blob;
530         else
531                 return lookup_blob(table, strm->_stream_hash);
532 }
533
534 /* Return the SHA-1 message digest of the data of the specified stream, or a
535  * void SHA-1 of all zeroes if the specified stream is empty.   */
536 const u8 *
537 stream_hash(const struct wim_inode_stream *strm)
538 {
539         if (strm->stream_resolved)
540                 return strm->_stream_blob ? strm->_stream_blob->hash : zero_hash;
541         else
542                 return strm->_stream_hash;
543 }
544
545 /*
546  * Return the blob descriptor for the unnamed data stream of the inode, or NULL
547  * if the inode does not have an unnamed data stream, the blob for the inode's
548  * unnamed data stream is empty, or the blob for the inode's unnamed data stream
549  * is not available in @blob_table.
550  */
551 struct blob_descriptor *
552 inode_get_blob_for_unnamed_data_stream(const struct wim_inode *inode,
553                                        const struct blob_table *blob_table)
554 {
555         const struct wim_inode_stream *strm;
556
557         strm = inode_get_unnamed_stream(inode, STREAM_TYPE_DATA);
558         if (!strm)
559                 return NULL;
560
561         return stream_blob(strm, blob_table);
562 }
563
564 /* Like inode_get_blob_for_unnamed_data_stream(), but assumes the unnamed data
565  * stream is resolved.  */
566 struct blob_descriptor *
567 inode_get_blob_for_unnamed_data_stream_resolved(const struct wim_inode *inode)
568 {
569         const struct wim_inode_stream *strm;
570
571         strm = inode_get_unnamed_stream(inode, STREAM_TYPE_DATA);
572         if (!strm)
573                 return NULL;
574
575         return stream_blob_resolved(strm);
576 }
577
578 /*
579  * Return the SHA-1 message digest of the unnamed data stream of the inode, or a
580  * void SHA-1 of all zeroes if the inode does not have an unnamed data stream or
581  * if the inode's unnamed data stream is empty.
582  */
583 const u8 *
584 inode_get_hash_of_unnamed_data_stream(const struct wim_inode *inode)
585 {
586         const struct wim_inode_stream *strm;
587
588         strm = inode_get_unnamed_stream(inode, STREAM_TYPE_DATA);
589         if (!strm)
590                 return zero_hash;
591
592         return stream_hash(strm);
593 }
594
595 /* Acquire another reference to each blob referenced by this inode.  This is
596  * necessary when creating a hard link to this inode.
597  *
598  * All streams of the inode must be resolved.  */
599 void
600 inode_ref_blobs(struct wim_inode *inode)
601 {
602         for (unsigned i = 0; i < inode->i_num_streams; i++) {
603                 struct blob_descriptor *blob;
604
605                 blob = stream_blob_resolved(&inode->i_streams[i]);
606                 if (blob)
607                         blob->refcnt++;
608         }
609 }
610
611 /* Release a reference to each blob referenced by this inode.  This is necessary
612  * when deleting a hard link to this inode.  */
613 void
614 inode_unref_blobs(struct wim_inode *inode, struct blob_table *blob_table)
615 {
616         for (unsigned i = 0; i < inode->i_num_streams; i++) {
617                 struct blob_descriptor *blob;
618
619                 blob = stream_blob(&inode->i_streams[i], blob_table);
620                 if (blob)
621                         blob_decrement_refcnt(blob, blob_table);
622         }
623 }
624
625 /*
626  * Given a blob descriptor, return a pointer to the pointer contained in the
627  * stream that references it.
628  *
629  * This is only possible for "unhashed" blobs, which are guaranteed to have only
630  * one referencing stream, and that reference is guaranteed to be in a resolved
631  * stream.  (It can't be in an unresolved stream, since that would imply the
632  * hash is known!)
633  */
634 struct blob_descriptor **
635 retrieve_pointer_to_unhashed_blob(struct blob_descriptor *blob)
636 {
637         wimlib_assert(blob->unhashed);
638
639         struct wim_inode *inode = blob->back_inode;
640         for (unsigned i = 0; i < inode->i_num_streams; i++) {
641                 if (inode->i_streams[i].stream_id == blob->back_stream_id) {
642                         wimlib_assert(inode->i_streams[i]._stream_blob == blob);
643                         return &inode->i_streams[i]._stream_blob;
644                 }
645         }
646
647         wimlib_assert(0);
648         return NULL;
649 }